If you’re new to Proxy, check out our GitHub repository<\/a> and our previous announcements: Announcing the Proxy 3 Library for Dynamic Polymorphism<\/a> and Analyzing the Performance of the “Proxy” Library<\/a>.<\/p>\n We’ve launched a new documentation website, built with MkDocs, to help you find everything you need about Proxy. The new site offers improved navigation, a unified FAQ, and a clear structure for all features and APIs. Explore the documentation<\/a> and discover how easy it is to get started!<\/p>\n You can now experiment with Proxy directly in your browser using Compiler Explorer<\/a>! Write, run, and inspect Proxy code without any setup. Just click on “Libraries” and search for “proxy” in Compiler Explorer or use a shared link from our examples to get started. It’s a great way to see Proxy in action and share your findings with others.<\/p>\n Let’s see how easy it is to add formatting support to your types (run in Compiler Explorer<\/a>):<\/p>\n Skills are reusable building blocks that let you add powerful capabilities to your facades with a single line:<\/p>\n Skills are easy to compose and extend. You can also author internal, domain\u2011specific skills to capture patterns (logging, metrics hooks, validation, instrumentation) so teams reuse a single, well-reviewed definition instead of duplicating conventions. This improves consistency and long\u2011term maintainability. See the skills documentation<\/a> for more.<\/p>\n Proxy 4 introduces convenient aliases for non-owning and weak references: With the new Proxy 4 introduces See the Upgrading a small component is usually straightforward, but migrating a monorepo or multi-module product can be challenging. Follow the guidelines below:<\/p>\n The newest release re-exports its namespace as the inline (default) namespace, so unqualified calls ( These rules let old and new code coexist during the transition while keeping ODR violations at bay.<\/p>\n Proxy 4 builds on a mature foundation introduced and proven in Proxy 3, and adds focused refinements rather than reinventing the model.<\/p>\n Core capabilities (established in Proxy 3 and still central in day\u2011to\u2011day use):<\/p>\n Targeted Proxy 4 refinements:<\/p>\n Questions and feedback are welcome! If you find something unclear, a bug, or a documentation gap, feel free to open an issue or submit a PR.<\/p>\n","protected":false},"excerpt":{"rendered":" Version 4 of Microsoft’s Proxy library brings feature improvements, better diagnostics, better code generation, modern compiler\/debugger support.<\/p>\n","protected":false},"author":98503,"featured_media":35677,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[270,1],"tags":[],"class_list":["post-35676","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-announcement","category-cplusplus"],"acf":[],"blog_post_summary":" Version 4 of Microsoft’s Proxy library brings feature improvements, better diagnostics, better code generation, modern compiler\/debugger support.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/35676","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/users\/98503"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=35676"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/35676\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media\/35677"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media?parent=35676"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=35676"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=35676"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}New Website: Your One-Stop Reference<\/h2>\n
![\"Index\"](\"https:\/\/devblogs.microsoft.com\/cppblog\/wp-content\/uploads\/sites\/9\/2025\/08\/index.png\")
<\/p>\nTry Proxy Instantly in Compiler Explorer<\/h2>\n
![\"Compiler](\"https:\/\/devblogs.microsoft.com\/cppblog\/wp-content\/uploads\/sites\/9\/2025\/08\/compiler-explorer.png\")
<\/p>\nWhat’s New in Proxy 4?<\/h2>\n
Skills: Composable Facade Capabilities<\/h3>\n
#include <format>\r\n#include <proxy\/proxy.h>\r\n\r\nstruct Formattable : pro::facade_builder\r\n ::add_skill<pro::skills::format>\r\n ::build {};\r\n\r\nint main() {\r\n pro::proxy<Formattable> p = pro::make_proxy<Formattable>(123);\r\n std::cout << std::format(\"{}\\n\", *p); \/\/ Prints \"123\"\r\n}<\/code><\/pre>\n\n
skills::format<\/code> and skills::wformat<\/code><\/a>: Enable standard C++ formatting for your proxies. This was never possible with virtual functions or earlier Proxy versions.<\/li>\nskills::fmt_format<\/code> and skills::fmt_wformat<\/code><\/a>: Bring full {fmt} library<\/a> support to your proxies, letting you use advanced formatting features with zero boilerplate.<\/li>\nskills::rtti<\/code><\/a>: Add runtime type information and safe casting to your proxies.<\/li>\nskills::as_view<\/code><\/a> and skills::as_weak<\/code><\/a>: Allow seamless conversion to non-owning or weak proxies, making your code safer and more expressive.<\/li>\nskills::slim<\/code><\/a>: Restrict your proxy to pointer-sized storage for maximum efficiency.<\/li>\n<\/ul>\nEasy Borrowing and Weak References<\/h3>\n
proxy_view<\/code> and weak_proxy<\/code>. These are built on top of the core proxy<\/code> concept, making it easier to express borrowing and weak ownership patterns in your code. For example, you can use proxy_view<\/code> to safely borrow an object without taking ownership, or weak_proxy<\/code> to create a weak reference that can be locked when needed. See the proxy_view<\/code> documentation<\/a> and weak_proxy<\/code> documentation<\/a> for details.<\/p>\nShared Ownership Made Simple<\/h3>\n
make_proxy_shared<\/code> and allocate_proxy_shared<\/code> APIs, you can create shared and weak proxies efficiently, without the overhead of std::shared_ptr<\/code>. These APIs use compact internal pointer types, ensuring high performance and low memory usage. Learn more in the make_proxy_shared<\/code> documentation<\/a> and allocate_proxy_shared<\/code> documentation<\/a>.<\/p>\nSmarter Dispatch and Conversion<\/h2>\n
\n
weak_dispatch<\/code><\/a> lets you define fallback behavior for missing conventions, so your code can handle incomplete types gracefully.<\/li>\nexplicit_conversion_dispatch<\/code><\/a>, implicit_conversion_dispatch<\/code><\/a>) are now easier to use and provide clearer error messages.<\/li>\nproxiable_target<\/code><\/a> and inplace_proxiable_target<\/code><\/a> concepts make it clear which target types can be used with a given facade, helping you avoid surprises and write safer code.<\/li>\n<\/ul>\nRecursive Facade Patterns Made Easy<\/h2>\n
facade_aware_overload_t<\/code>, which lets you define recursive conventions that refer to the facade itself without forcing early instantiation. This is especially useful for operator chaining patterns (like arithmetic or concatenation) that return new proxy<\/code> objects of the same facade. Example:<\/p>\n#include <format>\r\n#include <iostream>\r\n#include <proxy\/proxy.h>\r\n\r\ntemplate <class F>\r\nusing BinaryOverload =\r\n pro::proxy<F>(const pro::proxy_indirect_accessor<F>& rhs) const;\r\n\r\ntemplate <class T, pro::facade F>\r\npro::proxy<F> operator+(const T& value,\r\n const pro::proxy_indirect_accessor<F>& rhs)\r\n requires(!std::is_same_v<T, pro::proxy_indirect_accessor<F>>)\r\n{\r\n return pro::make_proxy<F, T>(value + proxy_cast<const T&>(rhs));\r\n}\r\n\r\nstruct Addable\r\n : pro::facade_builder \/\/ Compose capabilities\r\n ::add_skill<pro::skills::rtti> \/\/ RTTI support\r\n ::add_skill<pro::skills::format> \/\/ Formatting support\r\n ::add_convention<pro::operator_dispatch<\"+\">,\r\n pro::facade_aware_overload_t<BinaryOverload>> \/\/ Recursive operator\r\n ::build {};\r\n\r\nint main() {\r\n pro::proxy<Addable> p1 = pro::make_proxy<Addable>(1);\r\n pro::proxy<Addable> p2 = pro::make_proxy<Addable>(2);\r\n pro::proxy<Addable> p3 = *p1 + *p2; \/\/ Uses facade-aware overload\r\n std::cout << std::format(\"{}\\n\", *p3); \/\/ Prints \"3\"\r\n}<\/code><\/pre>\nfacade_aware_overload_t<\/code> documentation<\/a> for details.<\/p>\nQuality Improvements for Everyone<\/h2>\n
\n
memcpy<\/code>, enabling faster moves and assignments by default. This means better performance and less boilerplate for you. See the is_bitwise_trivially_relocatable<\/code> documentation<\/a> for more details.<\/li>\n.ixx<\/code> files for blazing-fast builds and better IDE support.<\/li>\nMajor Version Compatibility<\/h2>\n
\n
\n
pro::v3<\/code>, pro::v4<\/code>, \u2026).\u00a0 When a translation unit sees multiple majors, qualify the namespace explicitly:\npro::v3::foo(); \/\/ Proxy 3 API\r\npro::v4::foo(); \/\/ Proxy 4 API<\/code><\/pre>\npro::foo()<\/code>) resolve to the latest version once the migration is complete.<\/li>\nPRO4_DEF_MEM_DISPATCH<\/code><\/a>. Use these forms whenever headers from multiple majors are included in the same translation unit.<\/li>\nOther Notable Changes<\/h2>\n
\n
PRO_DEF_WEAK_DISPATCH<\/code> has been removed in favor of the more flexible weak_dispatch<\/code><\/a> class.<\/li>\nproxiable_ptr_constraints<\/code> has been merged into the ProFacade<\/em> requirements<\/a> for simplicity.<\/li>\naccess_proxy<\/code> is now shadowed by proxy_invoke<\/code><\/a> and proxy_reflect<\/code><\/a>.<\/li>\nSummary<\/h2>\n
\n
make_proxy<\/code><\/a> (inline where possible), allocate_proxy<\/code><\/a> (custom allocators), raw pointer attachment, unique ownership, and composition of abstractions via add_convention<\/code><\/a> \/ add_reflection<\/code><\/a> \/ add_facade<\/code><\/a>.<\/li>\nproxy<\/code><\/a> type: same facade supports non\u2011owning, unique, inline, or externally managed objects transparently.<\/li>\n\n
proxy_view<\/code><\/a>, weak_proxy<\/code><\/a>) built atop the existing core.<\/li>\nmake_proxy_shared<\/code><\/a>, allocate_proxy_shared<\/code><\/a>) complement (not replace) the more frequently used make_proxy<\/code> \/ allocate_proxy<\/code> paths.<\/li>\nproxiable_target<\/code><\/a>, inplace_proxiable_target<\/code><\/a>) clarify when a type can be used with make_proxy<\/code> versus make_proxy_inplace<\/code>, giving earlier, sharper diagnostics instead of template noise.<\/li>\nfacade_aware_overload_t<\/code><\/a> enables recursive facade\/operator definitions (e.g. arithmetic that returns the same facade) without forcing premature instantiation.<\/li>\nweak_dispatch<\/code><\/a> for graceful fallback when some contained types omit a convention.<\/li>\nis_bitwise_trivially_relocatable<\/code><\/a>), module support, and leaner code generation.<\/li>\n<\/ul>\n