<!doctype html><html lang=en-US dir=ltr class="docs-wrapper plugin-docs plugin-id-default docs-version-1.3.0 docs-doc-page docs-doc-id-compiler/compiler_guide" data-has-hydrated=false><head><meta charset=UTF-8><meta name=generator content="Docusaurus v3.10.1"><title data-rh=true>Compiler Guide | Apache Fory™</title><meta data-rh=true name=viewport content="width=device-width, initial-scale=1.0"/><meta data-rh=true property=og:url content=https://fory.apache.org/docs/compiler/compiler_guide /><meta data-rh=true property=og:locale content=en_US /><meta data-rh=true property=og:locale:alternate content=zh_CN /><meta data-rh=true name=docusaurus_locale content=en-US /><meta data-rh=true name=docsearch:language content=en-US /><meta data-rh=true http-equiv=Content-Security-Policy content="frame-src 'self' https://ghbtns.com/;"/><meta data-rh=true property=og:image content=https://fory.apache.org/img/logo.png /><meta data-rh=true property=og:image:width content=1500 /><meta data-rh=true property=og:image:height content=1500 /><meta data-rh=true name=twitter:card content=summary_large_image /><meta data-rh=true name=twitter:image content=https://fory.apache.org/img/logo.png /><meta data-rh=true name=docusaurus_version content=1.3.0 /><meta data-rh=true name=docusaurus_tag content=docs-default-1.3.0 /><meta data-rh=true name=docsearch:version content=1.3.0 /><meta data-rh=true name=docsearch:docusaurus_tag content=docs-default-1.3.0 /><meta data-rh=true property=og:title content="Compiler Guide | Apache Fory™"/><meta data-rh=true name=description content="This guide covers installation, usage, and integration of the Fory IDL compiler."/><meta data-rh=true property=og:description content="This guide covers installation, usage, and integration of the Fory IDL compiler."/><link data-rh=true rel=icon href=/img/favicon.ico /><link data-rh=true rel=canonical href=https://fory.apache.org/docs/compiler/compiler_guide /><link data-rh=true rel=alternate href=https://fory.apache.org/docs/compiler/compiler_guide hreflang=en-US /><link data-rh=true rel=alternate href=https://fory.apache.org/zh-CN/docs/compiler/compiler_guide hreflang=zh-CN /><link data-rh=true rel=alternate href=https://fory.apache.org/docs/compiler/compiler_guide hreflang=x-default /><script data-rh=true type=application/ld+json>{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","item":"https://fory.apache.org/docs/compiler/compiler_guide","name":"Compiler Guide","position":1}]}</script><link rel=alternate type=application/rss+xml href=/blog/rss.xml title="Apache Fory™ RSS Feed"><link rel=alternate type=application/atom+xml href=/blog/atom.xml title="Apache Fory™ Atom Feed"><script type=text/javascript>"fury.apache.org"===window.location.host&&(window.location.href="https://fory.apache.org"),function(){for(var o=window.location.pathname,a=["guide","introduction","start"],n=0;n<a.length;n++){var t=a[n],i=RegExp("^((?:/[a-z]{2}-[A-Z]{2})?/docs(?:/(?:next|[0-9]+.[0-9]+))?)/docs/"+t+"(/.*)?$"),c=o.match(i);if(c){var r=c[1]+"/"+t+(c[2]||"");window.location.replace(r+window.location.search+window.location.hash);return}}}()</script><link rel=stylesheet href=/assets/css/styles.3a1edaa1.css /><script src=/assets/js/runtime~main.605b11b1.js defer></script><script src=/assets/js/main.283fea4b.js defer></script></head><body><svg style="display: none;"><defs>
<symbol id=theme-svg-external-link viewBox="0 0 24 24"><path fill=currentColor d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"/></symbol>
</defs></svg>
<script>!function(){var t=function(){try{return new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}}()||function(){try{return window.localStorage.getItem("theme")}catch(t){}}();document.documentElement.setAttribute("data-theme",t||"light"),document.documentElement.setAttribute("data-theme-choice",t||"light")}(),function(){try{for(var[t,e]of new URLSearchParams(window.location.search).entries())if(t.startsWith("docusaurus-data-")){var a=t.replace("docusaurus-data-","data-");document.documentElement.setAttribute(a,e)}}catch(t){}}()</script><div id=__docusaurus><div role=region aria-label="Skip to main content"><a class=skipToContent_fXgn href=#__docusaurus_skipToContent_fallback>Skip to main content</a></div><nav aria-label=Main class="theme-layout-navbar navbar navbar--fixed-top"><div class=navbar__inner><div class="theme-layout-navbar-left navbar__items"><button aria-label="Toggle navigation bar" aria-expanded=false class="navbar__toggle clean-btn" type=button><svg width=30 height=30 viewBox="0 0 30 30" aria-hidden=true><path stroke=currentColor stroke-linecap=round stroke-miterlimit=10 stroke-width=2 d="M4 7h22M4 15h22M4 23h22"/></svg></button><a class=navbar__brand href=/><div class=navbar__logo><img src=/img/fory-logo-light.png alt="Apache Fory™ Logo" class="themedComponent_mlkZ themedComponent--light_NVdE"/><img src=/img/fory-logo-dark.png alt="Apache Fory™ Logo" class="themedComponent_mlkZ themedComponent--dark_xIcU"/></div><b class="navbar__title text--truncate"></b></a><a aria-current=page class="navbar__item navbar__link navbar__link--active" href=/docs/introduction/overview>Docs</a><a class="navbar__item navbar__link" href=/docs/specification/xlang_serialization_spec>Specification</a><a class="navbar__item navbar__link" href=/docs/community/>Community</a><a class="navbar__item navbar__link" href=/user>Users</a><a class="navbar__item navbar__link" href=/download>Download</a><a class="navbar__item navbar__link" href=/blog>Blog</a></div><div class="theme-layout-navbar-right navbar__items navbar__items--right"><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href=# aria-haspopup=true aria-expanded=false role=button class=navbar__link>ASF</a><ul class=dropdown__menu><li><a href=https://www.apache.org/ target=_blank rel="noopener noreferrer" class=dropdown__link>Foundation</a><li><a href=https://www.apache.org/licenses/ target=_blank rel="noopener noreferrer" class=dropdown__link>License</a><li><a href=https://www.apache.org/events/current-event.html target=_blank rel="noopener noreferrer" class=dropdown__link>Events</a><li><a href=https://privacy.apache.org/policies/privacy-policy-public.html target=_blank rel="noopener noreferrer" class=dropdown__link>Privacy</a><li><a href=https://www.apache.org/security/ target=_blank rel="noopener noreferrer" class=dropdown__link>Security</a><li><a href=https://www.apache.org/foundation/sponsorship.html target=_blank rel="noopener noreferrer" class=dropdown__link>Sponsorship</a><li><a href=https://www.apache.org/foundation/thanks.html target=_blank rel="noopener noreferrer" class=dropdown__link>Thanks</a><li><a href=https://www.apache.org/foundation/policies/conduct.html target=_blank rel="noopener noreferrer" class=dropdown__link>Code of Conduct</a></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a class=navbar__link aria-haspopup=true aria-expanded=false role=button href=/docs/compiler/compiler_guide>1.3.0</a><ul class=dropdown__menu><li><a class=dropdown__link href=/docs/next/compiler/compiler_guide>dev</a><li><a aria-current=page class="dropdown__link dropdown__link--active" href=/docs/compiler/compiler_guide>1.3.0</a><li><a class=dropdown__link href=/docs/1.2.0/compiler/compiler_guide>1.2.0</a><li><a class=dropdown__link href=/docs/1.1.0/compiler/compiler_guide>1.1.0</a><li><a class=dropdown__link href=/docs/1.0.0/compiler/compiler_guide>1.0.0</a><li><a class=dropdown__link href=/docs/0.17/compiler/compiler_guide>0.17</a><li><a class=dropdown__link href=/docs/0.16/compiler/compiler_guide>0.16</a><li><a class=dropdown__link href=/docs/0.15/compiler/compiler_guide>0.15</a><li><a class=dropdown__link href=/docs/0.14/introduction/overview>0.14</a><li><a class=dropdown__link href=/docs/0.13/introduction/overview>0.13</a><li><a class=dropdown__link href=/docs/0.12/introduction/overview>0.12</a><li><a class=dropdown__link href=/docs/0.11/introduction/overview>0.11</a><li><a class=dropdown__link href=/docs/0.10/introduction/overview>0.10</a></ul></div><a href=https://github.com/apache/fory target=_blank rel="noopener noreferrer" class="navbar__item navbar__link header-github-link" aria-label="GitHub repository"></a><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href=# aria-haspopup=true aria-expanded=false role=button class=navbar__link><svg viewBox="0 0 24 24" width=20 height=20 aria-hidden=true class=iconLanguage_nlXk><path fill=currentColor d="M12.87 15.07l-2.54-2.51.03-.03c1.74-1.94 2.98-4.17 3.71-6.53H17V4h-7V2H8v2H1v1.99h11.17C11.5 7.92 10.44 9.75 9 11.35 8.07 10.32 7.3 9.19 6.69 8h-2c.73 1.63 1.73 3.17 2.98 4.56l-5.09 5.02L4 19l5-5 3.11 3.11.76-2.04zM18.5 10h-2L12 22h2l1.12-3h4.75L21 22h2l-4.5-12zm-2.62 7l1.62-4.33L19.12 17h-3.24z"/></svg>English</a><ul class=dropdown__menu><li><a href=/docs/compiler/compiler_guide target=_self rel="noopener noreferrer" class="dropdown__link dropdown__link--active" lang=en-US>English</a><li><a href=/zh-CN/docs/compiler/compiler_guide target=_self rel="noopener noreferrer" class=dropdown__link lang=zh-CN>简体中文</a></ul></div><div class="toggle_vylO colorModeToggle_DEke"><button class="clean-btn toggleButton_gllP toggleButtonDisabled_aARS" type=button disabled title="system mode" aria-label="Switch between dark and light mode (currently system mode)"><svg viewBox="0 0 24 24" width=24 height=24 aria-hidden=true class="toggleIcon_g3eP lightToggleIcon_pyhR"><path fill=currentColor d="M12,9c1.65,0,3,1.35,3,3s-1.35,3-3,3s-3-1.35-3-3S10.35,9,12,9 M12,7c-2.76,0-5,2.24-5,5s2.24,5,5,5s5-2.24,5-5 S14.76,7,12,7L12,7z M2,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S1.45,13,2,13z M20,13l2,0c0.55,0,1-0.45,1-1 s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S19.45,13,20,13z M11,2v2c0,0.55,0.45,1,1,1s1-0.45,1-1V2c0-0.55-0.45-1-1-1S11,1.45,11,2z M11,20v2c0,0.55,0.45,1,1,1s1-0.45,1-1v-2c0-0.55-0.45-1-1-1C11.45,19,11,19.45,11,20z M5.99,4.58c-0.39-0.39-1.03-0.39-1.41,0 c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0s0.39-1.03,0-1.41L5.99,4.58z M18.36,16.95 c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0c0.39-0.39,0.39-1.03,0-1.41 L18.36,16.95z M19.42,5.99c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41 s1.03,0.39,1.41,0L19.42,5.99z M7.05,18.36c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06 c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L7.05,18.36z"/></svg><svg viewBox="0 0 24 24" width=24 height=24 aria-hidden=true class="toggleIcon_g3eP darkToggleIcon_wfgR"><path fill=currentColor d="M9.37,5.51C9.19,6.15,9.1,6.82,9.1,7.5c0,4.08,3.32,7.4,7.4,7.4c0.68,0,1.35-0.09,1.99-0.27C17.45,17.19,14.93,19,12,19 c-3.86,0-7-3.14-7-7C5,9.07,6.81,6.55,9.37,5.51z M12,3c-4.97,0-9,4.03-9,9s4.03,9,9,9s9-4.03,9-9c0-0.46-0.04-0.92-0.1-1.36 c-0.98,1.37-2.58,2.26-4.4,2.26c-2.98,0-5.4-2.42-5.4-5.4c0-1.81,0.89-3.42,2.26-4.4C12.92,3.04,12.46,3,12,3L12,3z"/></svg><svg viewBox="0 0 24 24" width=24 height=24 aria-hidden=true class="toggleIcon_g3eP systemToggleIcon_QzmC"><path fill=currentColor d="m12 21c4.971 0 9-4.029 9-9s-4.029-9-9-9-9 4.029-9 9 4.029 9 9 9zm4.95-13.95c1.313 1.313 2.05 3.093 2.05 4.95s-0.738 3.637-2.05 4.95c-1.313 1.313-3.093 2.05-4.95 2.05v-14c1.857 0 3.637 0.737 4.95 2.05z"/></svg></button></div><div class=navbarSearchContainer_Bca1><div class=navbar__search><span aria-label="expand searchbar" role=button class=search-icon tabindex=0></span><input id=search_input_react type=search placeholder=Loading... aria-label=Search class="navbar__search-input search-bar" disabled/></div></div></div></div><div role=presentation class=navbar-sidebar__backdrop></div></nav><div id=__docusaurus_skipToContent_fallback class="theme-layout-main main-wrapper mainWrapper_z2l0"><div class=docsWrapper_hBAB><button aria-label="Scroll back to top" class="clean-btn theme-back-to-top-button backToTopButton_sjWU" type=button></button><div class=docRoot_UBD9><aside class="theme-doc-sidebar-container docSidebarContainer_YfHR"><div class=sidebarViewport_aRkj><div class=sidebar_njMd><nav aria-label="Docs sidebar" class="menu thin-scrollbar menu_SIkG"><ul class="theme-doc-sidebar-menu menu__list"><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist menu__link--sublist-caret" role=button aria-expanded=true href=/docs/introduction/overview><span title=Introduction class=categoryLinkLabel_W154>Introduction</span></a></div><ul class=menu__list><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/introduction/overview><span title=Overview class=linkLabel_WmDU>Overview</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/introduction/features><span title=Features class=linkLabel_WmDU>Features</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/introduction/benchmark><span title=Benchmark class=linkLabel_WmDU>Benchmark</span></a></ul><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist menu__link--sublist-caret" role=button aria-expanded=true href=/docs/start/install><span title=Start class=categoryLinkLabel_W154>Start</span></a></div><ul class=menu__list><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/start/install><span title=Install class=linkLabel_WmDU>Install</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/start/usage><span title=Usage class=linkLabel_WmDU>Usage</span></a></ul><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist menu__link--sublist-caret menu__link--active" role=button aria-expanded=true href=/docs/compiler/><span title="Schema IDL & Compiler" class=categoryLinkLabel_W154>Schema IDL & Compiler</span></a></div><ul class=menu__list><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/compiler/><span title=Overview class=linkLabel_WmDU>Overview</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/compiler/syntax><span title="Schema IDL" class=linkLabel_WmDU>Schema IDL</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link menu__link--active" aria-current=page tabindex=0 href=/docs/compiler/compiler_guide><span title="Compiler Guide" class=linkLabel_WmDU>Compiler Guide</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/compiler/generated_code><span title="Generated Code" class=linkLabel_WmDU>Generated Code</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/compiler/flatbuffers_idl><span title="FlatBuffers IDL Support" class=linkLabel_WmDU>FlatBuffers IDL Support</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/compiler/protobuf_idl_support><span title="Protobuf IDL Support" class=linkLabel_WmDU>Protobuf IDL Support</span></a></ul><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist menu__link--sublist-caret" role=button aria-expanded=true href=/docs/guide/java/><span title=Guide class=categoryLinkLabel_W154>Guide</span></a></div><ul class=menu__list><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/java/><span title=Java class=categoryLinkLabel_W154>Java</span></a><button aria-label="Expand sidebar category 'Java'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/python/><span title=Python class=categoryLinkLabel_W154>Python</span></a><button aria-label="Expand sidebar category 'Python'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/rust/><span title=Rust class=categoryLinkLabel_W154>Rust</span></a><button aria-label="Expand sidebar category 'Rust'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/cpp/><span title=C++ class=categoryLinkLabel_W154>C++</span></a><button aria-label="Expand sidebar category 'C++'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/go/><span title=Go class=categoryLinkLabel_W154>Go</span></a><button aria-label="Expand sidebar category 'Go'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/javascript/><span title=JavaScript class=categoryLinkLabel_W154>JavaScript</span></a><button aria-label="Expand sidebar category 'JavaScript'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/csharp/><span title=C# class=categoryLinkLabel_W154>C#</span></a><button aria-label="Expand sidebar category 'C#'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/swift/><span title=Swift class=categoryLinkLabel_W154>Swift</span></a><button aria-label="Expand sidebar category 'Swift'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/dart/><span title=Dart class=categoryLinkLabel_W154>Dart</span></a><button aria-label="Expand sidebar category 'Dart'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/scala/><span title=Scala class=categoryLinkLabel_W154>Scala</span></a><button aria-label="Expand sidebar category 'Scala'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/kotlin/><span title=Kotlin class=categoryLinkLabel_W154>Kotlin</span></a><button aria-label="Expand sidebar category 'Kotlin'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/xlang/><span title="Cross Language" class=categoryLinkLabel_W154>Cross Language</span></a><button aria-label="Expand sidebar category 'Cross Language'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div></ul></ul></nav></div></div></aside><main class=docMainContainer_TBSr><div class="container padding-top--md padding-bottom--lg"><div class=row><div class="col docItemCol_VOVn"><div class=docItemContainer_Djhp><article><nav class="theme-doc-breadcrumbs breadcrumbsContainer_Z_bl" aria-label=Breadcrumbs><ul class=breadcrumbs><li class=breadcrumbs__item><a aria-label="Home page" class=breadcrumbs__link href=/><svg viewBox="0 0 24 24" class=breadcrumbHomeIcon_YNFT><path d="M10 19v-5h4v5c0 .55.45 1 1 1h3c.55 0 1-.45 1-1v-7h1.7c.46 0 .68-.57.33-.87L12.67 3.6c-.38-.34-.96-.34-1.34 0l-8.36 7.53c-.34.3-.13.87.33.87H5v7c0 .55.45 1 1 1h3c.55 0 1-.45 1-1z" fill=currentColor /></svg></a><li class=breadcrumbs__item><span class=breadcrumbs__link>Schema IDL & Compiler</span><li class="breadcrumbs__item breadcrumbs__item--active"><span class=breadcrumbs__link>Compiler Guide</span></ul></nav><span class="theme-doc-version-badge badge badge--secondary">Version: 1.3.0</span><div class="tocCollapsible_ETCw theme-doc-toc-mobile tocMobile_ITEo"><button type=button class="clean-btn tocCollapsibleButton_TO0P">On this page</button></div><div class="theme-doc-markdown markdown"><header><h1>Compiler Guide</h1></header><p>This guide covers installation, usage, and integration of the Fory IDL compiler.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=installation>Installation<a href=#installation class=hash-link aria-label="Direct link to Installation" title="Direct link to Installation" translate=no>​</a></h2>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=from-source>From Source<a href=#from-source class=hash-link aria-label="Direct link to From Source" title="Direct link to From Source" translate=no>​</a></h3>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token builtin class-name">cd</span><span class="token plain"> compiler</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">pip </span><span class="token function" style=color:#d73a49>install</span><span class="token plain"> </span><span class="token parameter variable" style=color:#36acaa>-e</span><span class="token plain"> </span><span class="token builtin class-name">.</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=verify-installation>Verify Installation<a href=#verify-installation class=hash-link aria-label="Direct link to Verify Installation" title="Direct link to Verify Installation" translate=no>​</a></h3>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">foryc </span><span class="token parameter variable" style=color:#36acaa>--help</span><br/></div></code></pre></div></div>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=command-line-interface>Command Line Interface<a href=#command-line-interface class=hash-link aria-label="Direct link to Command Line Interface" title="Direct link to Command Line Interface" translate=no>​</a></h2>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=basic-usage>Basic Usage<a href=#basic-usage class=hash-link aria-label="Direct link to Basic Usage" title="Direct link to Basic Usage" translate=no>​</a></h3>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">foryc </span><span class="token punctuation" style=color:#393A34>[</span><span class="token plain">OPTIONS</span><span class="token punctuation" style=color:#393A34>]</span><span class="token plain"> FILES</span><span class="token punctuation" style=color:#393A34>..</span><span class="token plain">.</span><br/></div></code></pre></div></div>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">foryc --scan-generated </span><span class="token punctuation" style=color:#393A34>[</span><span class="token plain">OPTIONS</span><span class="token punctuation" style=color:#393A34>]</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=options>Options<a href=#options class=hash-link aria-label="Direct link to Options" title="Direct link to Options" translate=no>​</a></h3>
<p>Compile options:</p>
<table><thead><tr><th>Option<th>Description<th>Default<tbody><tr><td><code>--lang</code><td>Comma-separated target languages<td><code>all</code><tr><td><code>--output</code>, <code>-o</code><td>Output directory<td><code>./generated</code><tr><td><code>-I</code>, <code>--proto_path</code>, <code>--import_path</code><td>Add directory to import search path (can be repeated)<td>(none)<tr><td><code>--java_out=DST_DIR</code><td>Generate Java code in DST_DIR<td>(none)<tr><td><code>--python_out=DST_DIR</code><td>Generate Python code in DST_DIR<td>(none)<tr><td><code>--cpp_out=DST_DIR</code><td>Generate C++ code in DST_DIR<td>(none)<tr><td><code>--go_out=DST_DIR</code><td>Generate Go code in DST_DIR<td>(none)<tr><td><code>--rust_out=DST_DIR</code><td>Generate Rust code in DST_DIR<td>(none)<tr><td><code>--csharp_out=DST_DIR</code><td>Generate C# code in DST_DIR<td>(none)<tr><td><code>--javascript_out=DST_DIR</code><td>Generate JavaScript/TypeScript code in DST_DIR<td>(none)<tr><td><code>--swift_out=DST_DIR</code><td>Generate Swift code in DST_DIR<td>(none)<tr><td><code>--dart_out=DST_DIR</code><td>Generate Dart code in DST_DIR<td>(none)<tr><td><code>--scala_out=DST_DIR</code><td>Generate Scala 3 code in DST_DIR<td>(none)<tr><td><code>--kotlin_out=DST_DIR</code><td>Generate Kotlin code in DST_DIR<td>(none)<tr><td><code>--go_nested_type_style</code><td>Go nested type naming: <code>camelcase</code> or <code>underscore</code><td><code>underscore</code><tr><td><code>--swift_namespace_style</code><td>Swift namespace style: <code>enum</code> or <code>flatten</code><td><code>enum</code><tr><td><code>--emit-fdl</code><td>Emit translated FDL (for non-FDL inputs)<td><code>false</code><tr><td><code>--emit-fdl-path</code><td>Write translated FDL to this path (file or directory)<td>(stdout)<tr><td><code>--grpc</code><td>Generate gRPC service companions for supported outputs<td><code>false</code><tr><td><code>--grpc-python-mode=MODE</code><td>Python gRPC mode: <code>async</code> or <code>sync</code><td><code>async</code><tr><td><code>--grpc-web</code><td>Generate JavaScript gRPC-Web client companions<td><code>false</code></table>
<p>Schema-level file options are supported for language-specific generation choices.
For <code>go_nested_type_style</code> and <code>swift_namespace_style</code>, the CLI flag overrides
the schema option when both are present. Rust temporal codegen has no CLI flag:
set <code>option rust_use_chrono_temporal_types = true;</code> in the schema to generate
<code>chrono::NaiveDate</code>, <code>chrono::NaiveDateTime</code>, and <code>chrono::Duration</code> instead of
the default <code>fory::Date</code>, <code>fory::Timestamp</code>, and <code>fory::Duration</code>. Crates that
compile generated chrono-based Rust code must depend on <code>chrono</code> and enable
Fory's <code>chrono</code> feature.</p>
<p>Scan options (with <code>--scan-generated</code>):</p>
<table><thead><tr><th>Option<th>Description<th>Default<tbody><tr><td><code>--root</code><td>Root directory to scan<td><code>.</code><tr><td><code>--relative</code><td>Print paths relative to root<td><code>false</code><tr><td><code>--delete</code><td>Delete matched generated files<td><code>false</code><tr><td><code>--dry-run</code><td>Scan/print only, do not delete<td><code>false</code></table>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=scan-generated-files>Scan Generated Files<a href=#scan-generated-files class=hash-link aria-label="Direct link to Scan Generated Files" title="Direct link to Scan Generated Files" translate=no>​</a></h3>
<p>Use <code>--scan-generated</code> to find files produced by <code>foryc</code>. The scanner walks
the tree recursively, skips <code>build/</code>, <code>target/</code>, and hidden directories, and prints
each generated file as it is found.</p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token comment" style=color:#999988;font-style:italic># Scan current directory</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc --scan-generated</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Scan a specific root</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc --scan-generated </span><span class="token parameter variable" style=color:#36acaa>--root</span><span class="token plain"> ./src</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Print paths relative to the scan root</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc --scan-generated </span><span class="token parameter variable" style=color:#36acaa>--root</span><span class="token plain"> ./src </span><span class="token parameter variable" style=color:#36acaa>--relative</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Delete scanned generated files</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc --scan-generated </span><span class="token parameter variable" style=color:#36acaa>--root</span><span class="token plain"> ./src </span><span class="token parameter variable" style=color:#36acaa>--delete</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Dry-run (scan and print only)</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc --scan-generated </span><span class="token parameter variable" style=color:#36acaa>--root</span><span class="token plain"> ./src --dry-run</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=examples>Examples<a href=#examples class=hash-link aria-label="Direct link to Examples" title="Direct link to Examples" translate=no>​</a></h3>
<p><strong>Compile for all languages:</strong></p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">foryc schema.fdl</span><br/></div></code></pre></div></div>
<p><strong>Compile for a selected subset of languages:</strong></p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">foryc schema.fdl </span><span class="token parameter variable" style=color:#36acaa>--lang</span><span class="token plain"> java,python,csharp,javascript,swift,dart,kotlin</span><br/></div></code></pre></div></div>
<p><strong>Specify output directory:</strong></p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">foryc schema.fdl </span><span class="token parameter variable" style=color:#36acaa>--output</span><span class="token plain"> ./src/generated</span><br/></div></code></pre></div></div>
<p><strong>Compile multiple files:</strong></p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">foryc user.fdl order.fdl product.fdl </span><span class="token parameter variable" style=color:#36acaa>--output</span><span class="token plain"> ./generated</span><br/></div></code></pre></div></div>
<p><strong>Compile a simple schema containing service definitions (Java + Python + Go + Rust + C# + Dart + Scala + Kotlin + JavaScript models):</strong></p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">foryc compiler/examples/service.fdl </span><span class="token parameter variable" style=color:#36acaa>--java_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/java </span><span class="token parameter variable" style=color:#36acaa>--python_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/python </span><span class="token parameter variable" style=color:#36acaa>--go_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/go </span><span class="token parameter variable" style=color:#36acaa>--rust_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/rust </span><span class="token parameter variable" style=color:#36acaa>--csharp_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/csharp </span><span class="token parameter variable" style=color:#36acaa>--dart_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/dart </span><span class="token parameter variable" style=color:#36acaa>--scala_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/scala </span><span class="token parameter variable" style=color:#36acaa>--kotlin_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/kotlin </span><span class="token parameter variable" style=color:#36acaa>--javascript_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/javascript</span><br/></div></code></pre></div></div>
<p><strong>Generate Java, Python, Go, Rust, C#, Dart, Scala, Kotlin, and Node.js JavaScript gRPC service companions:</strong></p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">foryc compiler/examples/service.fdl </span><span class="token parameter variable" style=color:#36acaa>--java_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/java </span><span class="token parameter variable" style=color:#36acaa>--python_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/python </span><span class="token parameter variable" style=color:#36acaa>--go_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/go </span><span class="token parameter variable" style=color:#36acaa>--rust_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/rust </span><span class="token parameter variable" style=color:#36acaa>--csharp_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/csharp </span><span class="token parameter variable" style=color:#36acaa>--dart_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/dart </span><span class="token parameter variable" style=color:#36acaa>--scala_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/scala </span><span class="token parameter variable" style=color:#36acaa>--kotlin_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/kotlin </span><span class="token parameter variable" style=color:#36acaa>--javascript_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/javascript </span><span class="token parameter variable" style=color:#36acaa>--grpc</span><br/></div></code></pre></div></div>
<p>The generated gRPC service code uses Fory to serialize request and response
payloads. Java output imports grpc-java APIs, Python output defaults to
<code>grpc.aio</code>, Go output imports grpc-go, Rust output imports <code>tonic</code> and <code>bytes</code>,
Scala output imports grpc-java APIs, and Kotlin output imports grpc-java and
grpc-kotlin APIs and uses coroutine stubs. C# output imports <code>Grpc.Core.Api</code>
types and can be hosted with normal .NET gRPC packages such as <code>Grpc.AspNetCore</code>
or called through <code>Grpc.Net.Client</code>. Dart output imports <code>package:grpc</code>.
JavaScript output imports <code>@grpc/grpc-js</code>.
Applications that compile or run those generated service files must provide
their own gRPC dependencies. Fory packages do not add a hard gRPC dependency for
this feature.</p>
<p>Generate synchronous Python gRPC companions for existing sync <code>grpcio</code>
applications with:</p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">foryc compiler/examples/service.fdl </span><span class="token parameter variable" style=color:#36acaa>--python_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/python </span><span class="token parameter variable" style=color:#36acaa>--grpc</span><span class="token plain"> --grpc-python-mode</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">sync</span><br/></div></code></pre></div></div>
<p><strong>Generate JavaScript gRPC-Web browser clients:</strong></p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">foryc compiler/examples/service.fdl </span><span class="token parameter variable" style=color:#36acaa>--javascript_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./generated/javascript --grpc-web</span><br/></div></code></pre></div></div>
<p>Use <code>--grpc</code> and <code>--grpc-web</code> together when the same JavaScript output should
include both Node.js and browser companions. The browser companion imports
<code>grpc-web</code>; the application must provide the package and a gRPC-Web compatible
server or proxy.</p>
<p><strong>Use import search paths:</strong></p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token comment" style=color:#999988;font-style:italic># Add a single import path</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc src/main.fdl </span><span class="token parameter variable" style=color:#36acaa>-I</span><span class="token plain"> libs/common</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Add multiple import paths (repeated option)</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc src/main.fdl </span><span class="token parameter variable" style=color:#36acaa>-I</span><span class="token plain"> libs/common </span><span class="token parameter variable" style=color:#36acaa>-I</span><span class="token plain"> libs/types</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Add multiple import paths (comma-separated)</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc src/main.fdl </span><span class="token parameter variable" style=color:#36acaa>-I</span><span class="token plain"> libs/common,libs/types,third_party/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Using --proto_path (protoc-compatible alias)</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc src/main.fdl </span><span class="token parameter variable" style=color:#36acaa>--proto_path</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">libs/common</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Mix all styles</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc src/main.fdl </span><span class="token parameter variable" style=color:#36acaa>-I</span><span class="token plain"> libs/common,libs/types </span><span class="token parameter variable" style=color:#36acaa>--proto_path</span><span class="token plain"> third_party/</span><br/></div></code></pre></div></div>
<p><strong>Language-specific output directories (protoc-style):</strong></p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token comment" style=color:#999988;font-style:italic># Generate only Java code to a specific directory</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc schema.fdl </span><span class="token parameter variable" style=color:#36acaa>--java_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./src/main/java</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Generate multiple languages to different directories</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc schema.fdl </span><span class="token parameter variable" style=color:#36acaa>--java_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./java/gen </span><span class="token parameter variable" style=color:#36acaa>--python_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./python/src </span><span class="token parameter variable" style=color:#36acaa>--cpp_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./cpp/gen </span><span class="token parameter variable" style=color:#36acaa>--go_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./go/gen </span><span class="token parameter variable" style=color:#36acaa>--rust_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./rust/gen </span><span class="token parameter variable" style=color:#36acaa>--csharp_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./csharp/gen </span><span class="token parameter variable" style=color:#36acaa>--javascript_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./javascript/src </span><span class="token parameter variable" style=color:#36acaa>--swift_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./swift/gen </span><span class="token parameter variable" style=color:#36acaa>--dart_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./dart/gen </span><span class="token parameter variable" style=color:#36acaa>--scala_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./scala/gen </span><span class="token parameter variable" style=color:#36acaa>--kotlin_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./kotlin/gen</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Combine with import paths</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc schema.fdl </span><span class="token parameter variable" style=color:#36acaa>--java_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./gen/java </span><span class="token parameter variable" style=color:#36acaa>-I</span><span class="token plain"> proto/ </span><span class="token parameter variable" style=color:#36acaa>-I</span><span class="token plain"> common/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Generate Scala 3 code to a specific directory</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc schema.fdl </span><span class="token parameter variable" style=color:#36acaa>--scala_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./src/main/scala</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Generate Scala 3 models and gRPC service companions</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc service.fdl </span><span class="token parameter variable" style=color:#36acaa>--scala_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./src/main/scala </span><span class="token parameter variable" style=color:#36acaa>--grpc</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Generate Kotlin code to a specific directory</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc schema.fdl </span><span class="token parameter variable" style=color:#36acaa>--kotlin_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">./src/main/kotlin</span><br/></div></code></pre></div></div>
<p>When using <code>--{lang}_out</code> options:</p>
<ul>
<li class="">Only the specified languages are generated (not all languages)</li>
<li class="">The compiler writes under the specified directory (language-specific generators may still create package/module subdirectories)</li>
<li class="">This is compatible with protoc-style workflows</li>
</ul>
<p><strong>Inspect translated Fory IDL from proto/fbs input:</strong></p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token comment" style=color:#999988;font-style:italic># Print translated Fory IDL to stdout</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc schema.proto --emit-fdl</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Write translated Fory IDL to a directory</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc schema.fbs --emit-fdl --emit-fdl-path ./translated</span><br/></div></code></pre></div></div>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=import-path-resolution>Import Path Resolution<a href=#import-path-resolution class=hash-link aria-label="Direct link to Import Path Resolution" title="Direct link to Import Path Resolution" translate=no>​</a></h2>
<p>When compiling Fory IDL files with imports, the compiler searches for imported files in this order:</p>
<ol>
<li class=""><strong>Relative to the importing file (default)</strong> - The directory containing the file with the import statement is always searched first, automatically. No <code>-I</code> flag needed for same-directory imports.</li>
<li class=""><strong>Each <code>-I</code> path in order</strong> - Additional search paths specified on the command line</li>
</ol>
<p><strong>Same-directory imports work automatically:</strong></p>
<div class="language-protobuf codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-protobuf codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token comment" style=color:#999988;font-style:italic>// main.fdl</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token keyword" style=color:#00009f>import</span><span class="token plain"> </span><span class="token string" style=color:#e3116c>"common.fdl"</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain">  </span><span class="token comment" style=color:#999988;font-style:italic>// Found if common.fdl is in the same directory</span><br/></div></code></pre></div></div>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token comment" style=color:#999988;font-style:italic># No -I needed for same-directory imports</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">foryc main.fdl</span><br/></div></code></pre></div></div>
<p><strong>Example project structure:</strong></p>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">project/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">├── src/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">│   └── main.fdl          # import "common.fdl";</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">└── libs/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    └── common.fdl</span><br/></div></code></pre></div></div>
<p><strong>Without <code>-I</code> (fails):</strong></p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">$ foryc src/main.fdl</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">Import error: Import not found: common.fdl</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  Searched in: /project/src</span><br/></div></code></pre></div></div>
<p><strong>With <code>-I</code> (succeeds):</strong></p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">$ foryc src/main.fdl </span><span class="token parameter variable" style=color:#36acaa>-I</span><span class="token plain"> libs/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">Compiling src/main.fdl</span><span class="token punctuation" style=color:#393A34>..</span><span class="token plain">.</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  Resolved </span><span class="token number" style=color:#36acaa>1</span><span class="token plain"> import</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">s</span><span class="token punctuation" style=color:#393A34>)</span><br/></div></code></pre></div></div>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=supported-languages>Supported Languages<a href=#supported-languages class=hash-link aria-label="Direct link to Supported Languages" title="Direct link to Supported Languages" translate=no>​</a></h2>
<table><thead><tr><th>Language<th>Flag<th>Output Extension<th>Description<tbody><tr><td>Java<td><code>java</code><td><code>.java</code><td>POJOs with Fory annotations<tr><td>Python<td><code>python</code><td><code>.py</code><td>Dataclasses with type hints<tr><td>Go<td><code>go</code><td><code>.go</code><td>Structs with struct tags<tr><td>Rust<td><code>rust</code><td><code>.rs</code><td>Structs with derive macros<tr><td>C++<td><code>cpp</code><td><code>.h</code><td>Structs with FORY macros<tr><td>C#<td><code>csharp</code><td><code>.cs</code><td>Classes with Fory attributes<tr><td>JavaScript/TypeScript<td><code>javascript</code><td><code>.ts</code><td>Interfaces with schema module helpers<tr><td>Swift<td><code>swift</code><td><code>.swift</code><td>Fory Swift model macros<tr><td>Dart<td><code>dart</code><td><code>.dart</code><td><code>@ForyStruct</code> classes with annotations<tr><td>Scala<td><code>scala</code><td><code>.scala</code><td>Scala 3 models with macro derivation<tr><td>Kotlin<td><code>kotlin</code><td><code>.kt</code><td>Kotlin models with KSP serializers</table>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=output-structure>Output Structure<a href=#output-structure class=hash-link aria-label="Direct link to Output Structure" title="Direct link to Output Structure" translate=no>​</a></h2>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=java>Java<a href=#java class=hash-link aria-label="Direct link to Java" title="Direct link to Java" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">generated/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">└── java/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    └── com/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        └── example/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            ├── User.java</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            ├── Order.java</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            ├── Status.java</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            └── ExampleForyModule.java</span><br/></div></code></pre></div></div>
<ul>
<li class="">One file per type (enum or message)</li>
<li class="">Package structure matches Fory IDL package</li>
<li class="">Schema module class generated</li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=python>Python<a href=#python class=hash-link aria-label="Direct link to Python" title="Direct link to Python" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">generated/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">└── python/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    └── example.py</span><br/></div></code></pre></div></div>
<ul>
<li class="">Single module with all types</li>
<li class="">Module name derived from package</li>
<li class="">Registration function included</li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=go>Go<a href=#go class=hash-link aria-label="Direct link to Go" title="Direct link to Go" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">generated/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">└── go/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    └── example/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        └── example.go</span><br/></div></code></pre></div></div>
<ul>
<li class="">Single file with all types</li>
<li class="">Directory and package name are derived from <code>go_package</code> or the Fory IDL package</li>
<li class="">Registration function included</li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=rust>Rust<a href=#rust class=hash-link aria-label="Direct link to Rust" title="Direct link to Rust" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">generated/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">└── rust/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    └── example.rs</span><br/></div></code></pre></div></div>
<ul>
<li class="">Single module with all types</li>
<li class="">Module name derived from package</li>
<li class="">Registration function included</li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=c>C++<a href=#c class=hash-link aria-label="Direct link to C++" title="Direct link to C++" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">generated/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">└── cpp/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    └── example.h</span><br/></div></code></pre></div></div>
<ul>
<li class="">Single header file</li>
<li class="">Namespace matches package (dots to <code>::</code>)</li>
<li class="">Header guards and forward declarations</li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=javascripttypescript>JavaScript/TypeScript<a href=#javascripttypescript class=hash-link aria-label="Direct link to JavaScript/TypeScript" title="Direct link to JavaScript/TypeScript" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">generated/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">└── javascript/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    ├── example.ts</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    ├── example_grpc.ts      # with --grpc</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    └── example_grpc_web.ts  # with --grpc-web</span><br/></div></code></pre></div></div>
<ul>
<li class="">Single <code>.ts</code> file per schema</li>
<li class=""><code>export interface</code> declarations for messages</li>
<li class=""><code>export enum</code> declarations for enums</li>
<li class="">Discriminated unions with case enums</li>
<li class="">Schema helpers <code>registerXxxTypes(fory)</code> plus default <code>serializeX</code> and
<code>deserializeX</code> helpers included</li>
<li class=""><code>--grpc</code> emits a Node.js companion using <code>@grpc/grpc-js</code></li>
<li class=""><code>--grpc-web</code> emits a browser client companion using <code>grpc-web</code></li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=c-1>C#<a href=#c-1 class=hash-link aria-label="Direct link to C#" title="Direct link to C#" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">generated/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">└── csharp/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    └── example/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        └── Example.cs</span><br/></div></code></pre></div></div>
<ul>
<li class="">Single <code>.cs</code> file per schema named from the normalized PascalCase source file
stem</li>
<li class="">Namespace uses <code>csharp_namespace</code> (if set) or Fory IDL package</li>
<li class="">Includes source-file-prefixed <code>XXXForyModule</code> installation helper and
<code>ToBytes</code>/<code>FromBytes</code> methods</li>
<li class="">Imported schemas are installed transitively (for example <code>root.idl</code> importing
<code>addressbook.fdl</code> and <code>tree.fdl</code>)</li>
<li class="">With <code>--grpc</code>, one <code>&lt;ServiceName>Grpc.cs</code> companion per service next to the
schema file output</li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=swift>Swift<a href=#swift class=hash-link aria-label="Direct link to Swift" title="Direct link to Swift" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">generated/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">└── swift/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    └── addressbook/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        └── addressbook.swift</span><br/></div></code></pre></div></div>
<ul>
<li class="">Single <code>.swift</code> file per schema</li>
<li class="">Package segments are mapped to nested Swift enums (for example <code>addressbook.*</code> -> <code>Addressbook.*</code>)</li>
<li class="">Generated messages use <code>@ForyStruct</code>, enums use <code>@ForyEnum</code>, and unions use <code>@ForyUnion</code>/<code>@ForyCase</code></li>
<li class="">Union types are generated as tagged enums with associated payload values</li>
<li class="">Each schema includes a schema-file module owner and <code>toBytes</code>/<code>fromBytes</code>
helpers</li>
<li class="">Imported schemas are installed transitively by generated module helpers</li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=dart>Dart<a href=#dart class=hash-link aria-label="Direct link to Dart" title="Direct link to Dart" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">generated/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">└── dart/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    └── package/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        ├── package.dart</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        └── package.fory.dart</span><br/></div></code></pre></div></div>
<ul>
<li class="">Two files per schema: a main <code>.dart</code> file with annotated types, and a <code>.fory.dart</code> part file with generated serializers</li>
<li class="">Package segments map to directories (e.g., <code>demo.foo</code> → <code>demo/foo/</code>)</li>
<li class="">IDL module class included in the main file; generated serializer metadata is
included in the part file</li>
<li class="">Typed arrays used for non-optional, non-ref primitive lists (e.g., <code>Int32List</code>)</li>
<li class="">With <code>--grpc</code>, one <code>&lt;stem>_grpc.dart</code> companion per schema is generated next to
the model file, containing each service's <code>Client</code> and <code>ServiceBase</code>; it
imports <code>package:grpc</code></li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=scala>Scala<a href=#scala class=hash-link aria-label="Direct link to Scala" title="Direct link to Scala" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">generated/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">└── scala/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    └── example/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        ├── User.scala</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        ├── Status.scala</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        ├── Animal.scala</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        ├── ExampleServiceGrpc.scala</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        └── ExampleForyModule.scala</span><br/></div></code></pre></div></div>
<ul>
<li class="">One Scala 3 source file per generated type</li>
<li class="">Package structure matches the Fory IDL package</li>
<li class="">Messages derive <code>org.apache.fory.scala.ForySerializer</code></li>
<li class=""><code>optional T</code> fields use <code>Option[T]</code></li>
<li class="">Enums use Scala 3 <code>enum</code></li>
<li class="">Unions use Scala 3 ADT <code>enum</code> with <code>@ForyUnion</code>, <code>@ForyCase</code>, and an <code>Unknown</code></li>
<li class="">Schema module object included</li>
<li class="">With <code>--grpc</code>, one <code>&lt;ServiceName>Grpc.scala</code> service companion is generated
per local service definition</li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=kotlin>Kotlin<a href=#kotlin class=hash-link aria-label="Direct link to Kotlin" title="Direct link to Kotlin" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">generated/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">└── kotlin/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    └── example/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        ├── User.kt</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        ├── Status.kt</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        ├── Animal.kt</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        └── ExampleForyModule.kt</span><br/></div></code></pre></div></div>
<ul>
<li class="">One Kotlin source file per generated type</li>
<li class="">Package structure uses <code>kotlin_package</code> when set, otherwise the Fory IDL package</li>
<li class="">Messages use <code>@ForyStruct</code> and KSP-generated serializers</li>
<li class="">Enums use stable Fory enum IDs</li>
<li class="">Unions use sealed classes with <code>@ForyUnion</code>, <code>@ForyCase</code>, and an unknown-case carrier</li>
<li class="">Schema module object included</li>
<li class="">With <code>--grpc</code>, one <code>&lt;ServiceName>GrpcKt.kt</code> coroutine service companion per
service</li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=c-idl-matrix-verification>C# IDL Matrix Verification<a href=#c-idl-matrix-verification class=hash-link aria-label="Direct link to C# IDL Matrix Verification" title="Direct link to C# IDL Matrix Verification" translate=no>​</a></h3>
<p>Run the end-to-end C# IDL matrix (FDL/IDL/Proto/FBS generation plus roundtrip tests):</p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token builtin class-name">cd</span><span class="token plain"> integration_tests/idl_tests</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">./run_csharp_tests.sh</span><br/></div></code></pre></div></div>
<p>This runner executes same-schema and compatible roundtrips across:</p>
<ul>
<li class=""><code>addressbook</code>, <code>auto_id</code>, <code>complex_pb</code> primitives</li>
<li class=""><code>collection</code> and union/list variants</li>
<li class=""><code>optional_types</code></li>
<li class=""><code>any_example</code> (<code>.fdl</code>) and <code>any_example</code> (<code>.proto</code>)</li>
<li class=""><code>tree</code> and <code>graph</code> reference-tracking cases</li>
<li class=""><code>monster.fbs</code> and <code>complex_fbs.fbs</code></li>
<li class=""><code>root.idl</code> cross-package import coverage</li>
<li class="">evolving schema compatibility cases</li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=swift-idl-matrix-verification>Swift IDL Matrix Verification<a href=#swift-idl-matrix-verification class=hash-link aria-label="Direct link to Swift IDL Matrix Verification" title="Direct link to Swift IDL Matrix Verification" translate=no>​</a></h3>
<p>Run the end-to-end Swift IDL matrix (FDL/IDL/Proto/FBS generation plus roundtrip tests):</p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token builtin class-name">cd</span><span class="token plain"> integration_tests/idl_tests</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">./run_swift_tests.sh</span><br/></div></code></pre></div></div>
<p>This runs:</p>
<ul>
<li class="">local Swift IDL roundtrip tests in both compatible and same-schema modes</li>
<li class="">Java-driven peer roundtrip validation with <code>IDL_PEER_LANG=swift</code></li>
</ul>
<p>The script also sets <code>DATA_FILE*</code> variables so file-based roundtrip paths are exercised.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=build-integration>Build Integration<a href=#build-integration class=hash-link aria-label="Direct link to Build Integration" title="Direct link to Build Integration" translate=no>​</a></h2>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=maven-java>Maven (Java)<a href=#maven-java class=hash-link aria-label="Direct link to Maven (Java)" title="Direct link to Maven (Java)" translate=no>​</a></h3>
<p>Add to your <code>pom.xml</code>:</p>
<div class="language-xml codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-xml codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>build</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>plugins</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>plugin</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">      </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>groupId</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">org.codehaus.mojo</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>groupId</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">      </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>artifactId</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">exec-maven-plugin</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>artifactId</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">      </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>version</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">3.1.0</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>version</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">      </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>executions</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>execution</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">          </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>id</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">generate-fory-types</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>id</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">          </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>phase</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">generate-sources</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>phase</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">          </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>goals</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>goal</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">exec</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>goal</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">          </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>goals</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">          </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>configuration</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>executable</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">foryc</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>executable</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>arguments</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">              </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>argument</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">${project.basedir}/src/main/fdl/schema.fdl</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>argument</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">              </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>argument</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">--java_out</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>argument</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">              </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>argument</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">${project.build.directory}/generated-sources/fory</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>argument</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>arguments</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">          </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>configuration</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>execution</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">      </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>executions</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>plugin</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>plugins</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>build</span><span class="token tag punctuation" style=color:#393A34>></span><br/></div></code></pre></div></div>
<p>Add generated sources:</p>
<div class="language-xml codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-xml codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>build</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>plugins</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>plugin</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">      </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>groupId</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">org.codehaus.mojo</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>groupId</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">      </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>artifactId</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">build-helper-maven-plugin</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>artifactId</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">      </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>version</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">3.4.0</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>version</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">      </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>executions</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>execution</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">          </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>phase</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">generate-sources</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>phase</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">          </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>goals</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>goal</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">add-source</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>goal</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">          </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>goals</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">          </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>configuration</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>sources</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">              </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>source</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">${project.build.directory}/generated-sources/fory</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>source</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>sources</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">          </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>configuration</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>execution</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">      </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>executions</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>plugin</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>plugins</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>build</span><span class="token tag punctuation" style=color:#393A34>></span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=gradle-javakotlin>Gradle (Java/Kotlin)<a href=#gradle-javakotlin class=hash-link aria-label="Direct link to Gradle (Java/Kotlin)" title="Direct link to Gradle (Java/Kotlin)" translate=no>​</a></h3>
<p>Add to <code>build.gradle</code>:</p>
<div class="language-groovy codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-groovy codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">task generateForyTypes(type: Exec) {</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    commandLine 'foryc',</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        "${projectDir}/src/main/fdl/schema.fdl",</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        '--java_out', "${buildDir}/generated/sources/fory"</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">}</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">compileJava.dependsOn generateForyTypes</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">sourceSets {</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    main {</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        java {</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            srcDir "${buildDir}/generated/sources/fory"</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        }</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    }</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">}</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=python-setuptools>Python (setuptools)<a href=#python-setuptools class=hash-link aria-label="Direct link to Python (setuptools)" title="Direct link to Python (setuptools)" translate=no>​</a></h3>
<p>Add to <code>setup.py</code> or <code>pyproject.toml</code>:</p>
<div class="language-python codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-python codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token comment" style=color:#999988;font-style:italic># setup.py</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token keyword" style=color:#00009f>from</span><span class="token plain"> setuptools </span><span class="token keyword" style=color:#00009f>import</span><span class="token plain"> setup</span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token keyword" style=color:#00009f>from</span><span class="token plain"> setuptools</span><span class="token punctuation" style=color:#393A34>.</span><span class="token plain">command</span><span class="token punctuation" style=color:#393A34>.</span><span class="token plain">build_py </span><span class="token keyword" style=color:#00009f>import</span><span class="token plain"> build_py</span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token keyword" style=color:#00009f>import</span><span class="token plain"> subprocess</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token keyword" style=color:#00009f>class</span><span class="token plain"> </span><span class="token class-name">BuildWithForyIdl</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">build_py</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token keyword" style=color:#00009f>def</span><span class="token plain"> </span><span class="token function" style=color:#d73a49>run</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">self</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        subprocess</span><span class="token punctuation" style=color:#393A34>.</span><span class="token plain">run</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>[</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            </span><span class="token string" style=color:#e3116c>'foryc'</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            </span><span class="token string" style=color:#e3116c>'schema.fdl'</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">            </span><span class="token string" style=color:#e3116c>'--python_out'</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"> </span><span class="token string" style=color:#e3116c>'src/generated'</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        </span><span class="token punctuation" style=color:#393A34>]</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"> check</span><span class="token operator" style=color:#393A34>=</span><span class="token boolean" style=color:#36acaa>True</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        </span><span class="token builtin">super</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>.</span><span class="token plain">run</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">setup</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    cmdclass</span><span class="token operator" style=color:#393A34>=</span><span class="token punctuation" style=color:#393A34>{</span><span class="token string" style=color:#e3116c>'build_py'</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"> BuildWithForyIdl</span><span class="token punctuation" style=color:#393A34>}</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token comment" style=color:#999988;font-style:italic># ...</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token punctuation" style=color:#393A34>)</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=go-go-generate>Go (go generate)<a href=#go-go-generate class=hash-link aria-label="Direct link to Go (go generate)" title="Direct link to Go (go generate)" translate=no>​</a></h3>
<p>Add to your Go file:</p>
<div class="language-go codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-go codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token comment" style=color:#999988;font-style:italic>//go:generate foryc ../schema.fdl --lang go --output .</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token keyword" style=color:#00009f>package</span><span class="token plain"> models</span><br/></div></code></pre></div></div>
<p>Run:</p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">go generate ./</span><span class="token punctuation" style=color:#393A34>..</span><span class="token plain">.</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=rust-buildrs>Rust (build.rs)<a href=#rust-buildrs class=hash-link aria-label="Direct link to Rust (build.rs)" title="Direct link to Rust (build.rs)" translate=no>​</a></h3>
<p>Add to <code>build.rs</code>:</p>
<div class="language-rust codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-rust codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token keyword" style=color:#00009f>use</span><span class="token plain"> </span><span class="token namespace" style=opacity:0.7>std</span><span class="token namespace punctuation" style=opacity:0.7;color:#393A34>::</span><span class="token namespace" style=opacity:0.7>process</span><span class="token namespace punctuation" style=opacity:0.7;color:#393A34>::</span><span class="token class-name">Command</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token keyword" style=color:#00009f>fn</span><span class="token plain"> </span><span class="token function-definition function" style=color:#d73a49>main</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>{</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token macro property" style=color:#36acaa>println!</span><span class="token punctuation" style=color:#393A34>(</span><span class="token string" style=color:#e3116c>"cargo:rerun-if-changed=schema.fdl"</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token keyword" style=color:#00009f>let</span><span class="token plain"> status </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token class-name">Command</span><span class="token punctuation" style=color:#393A34>::</span><span class="token function" style=color:#d73a49>new</span><span class="token punctuation" style=color:#393A34>(</span><span class="token string" style=color:#e3116c>"foryc"</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        </span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>args</span><span class="token punctuation" style=color:#393A34>(</span><span class="token operator" style=color:#393A34>&</span><span class="token punctuation" style=color:#393A34>[</span><span class="token string" style=color:#e3116c>"schema.fdl"</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"> </span><span class="token string" style=color:#e3116c>"--rust_out"</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"> </span><span class="token string" style=color:#e3116c>"src/generated"</span><span class="token punctuation" style=color:#393A34>]</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        </span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>status</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        </span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>expect</span><span class="token punctuation" style=color:#393A34>(</span><span class="token string" style=color:#e3116c>"Failed to run foryc"</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token keyword" style=color:#00009f>if</span><span class="token plain"> </span><span class="token operator" style=color:#393A34>!</span><span class="token plain">status</span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>success</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>{</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        </span><span class="token macro property" style=color:#36acaa>panic!</span><span class="token punctuation" style=color:#393A34>(</span><span class="token string" style=color:#e3116c>"Fory IDL compilation failed"</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token punctuation" style=color:#393A34>}</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token punctuation" style=color:#393A34>}</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=cmake-c>CMake (C++)<a href=#cmake-c class=hash-link aria-label="Direct link to CMake (C++)" title="Direct link to CMake (C++)" translate=no>​</a></h3>
<p>Add to <code>CMakeLists.txt</code>:</p>
<div class="language-cmake codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-cmake codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">find_program(FORY_COMPILER foryc)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">add_custom_command(</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/generated/example.h</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    COMMAND ${FORY_COMPILER}</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        ${CMAKE_CURRENT_SOURCE_DIR}/schema.fdl</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">        --cpp_out ${CMAKE_CURRENT_SOURCE_DIR}/generated</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/schema.fdl</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    COMMENT "Generating Fory IDL types"</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">add_custom_target(generate_fory_idl DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/generated/example.h)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">add_library(mylib ...)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">add_dependencies(mylib generate_fory_idl)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">target_include_directories(mylib PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/generated)</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=bazel>Bazel<a href=#bazel class=hash-link aria-label="Direct link to Bazel" title="Direct link to Bazel" translate=no>​</a></h3>
<p>Create a rule in <code>BUILD</code>:</p>
<div class="language-python codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-python codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">genrule</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    name </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token string" style=color:#e3116c>"generate_fdl"</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    srcs </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>[</span><span class="token string" style=color:#e3116c>"schema.fdl"</span><span class="token punctuation" style=color:#393A34>]</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    outs </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>[</span><span class="token string" style=color:#e3116c>"generated/example.h"</span><span class="token punctuation" style=color:#393A34>]</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    cmd </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token string" style=color:#e3116c>"$(location //:fory_compiler) $(SRCS) --cpp_out $(RULEDIR)/generated"</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    tools </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>[</span><span class="token string" style=color:#e3116c>"//:fory_compiler"</span><span class="token punctuation" style=color:#393A34>]</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">cc_library</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    name </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token string" style=color:#e3116c>"models"</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    hdrs </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>[</span><span class="token string" style=color:#e3116c>":generate_fdl"</span><span class="token punctuation" style=color:#393A34>]</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token comment" style=color:#999988;font-style:italic># ...</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token punctuation" style=color:#393A34>)</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=dart--flutter>Dart / Flutter<a href=#dart--flutter class=hash-link aria-label="Direct link to Dart / Flutter" title="Direct link to Dart / Flutter" translate=no>​</a></h3>
<p>Add the Fory dependency to <code>pubspec.yaml</code>:</p>
<div class="language-yaml codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-yaml codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token key atrule" style=color:#00a4db>dependencies</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token key atrule" style=color:#00a4db>fory</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"> ^1.3.0</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token key atrule" style=color:#00a4db>dev_dependencies</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token key atrule" style=color:#00a4db>build_runner</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"> ^2.4.0</span><br/></div></code></pre></div></div>
<p>Generate schema types with the compiler:</p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">foryc schema.fdl </span><span class="token parameter variable" style=color:#36acaa>--dart_out</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">lib/generated</span><br/></div></code></pre></div></div>
<p>Then run <code>build_runner</code> to generate the serializers:</p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">dart run build_runner build</span><br/></div></code></pre></div></div>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=error-handling>Error Handling<a href=#error-handling class=hash-link aria-label="Direct link to Error Handling" title="Direct link to Error Handling" translate=no>​</a></h2>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=syntax-errors>Syntax Errors<a href=#syntax-errors class=hash-link aria-label="Direct link to Syntax Errors" title="Direct link to Syntax Errors" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">Error: Line 5, Column 12: Expected ';' after field declaration</span><br/></div></code></pre></div></div>
<p>Fix: Check the indicated line for missing semicolons or syntax issues.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=duplicate-type-names>Duplicate Type Names<a href=#duplicate-type-names class=hash-link aria-label="Direct link to Duplicate Type Names" title="Direct link to Duplicate Type Names" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">Error: Duplicate type name: User</span><br/></div></code></pre></div></div>
<p>Fix: Ensure each enum and message has a unique name within the file.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=duplicate-type-ids>Duplicate Type IDs<a href=#duplicate-type-ids class=hash-link aria-label="Direct link to Duplicate Type IDs" title="Direct link to Duplicate Type IDs" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">Error: Duplicate type ID 100: User and Order</span><br/></div></code></pre></div></div>
<p>Fix: Assign unique type IDs to each type.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=unknown-type-references>Unknown Type References<a href=#unknown-type-references class=hash-link aria-label="Direct link to Unknown Type References" title="Direct link to Unknown Type References" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">Error: Unknown type 'Address' in Customer.address</span><br/></div></code></pre></div></div>
<p>Fix: Define the referenced type before using it, or check for typos.</p>
<p>Service RPC request and response types are validated in the same way: an RPC such as
<code>rpc SayHello (HelloRequest) returns (HelloReply);</code> must reference defined message
types, otherwise the validator reports an <code>Unknown type '...'</code> error on the RPC line.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=duplicate-field-numbers>Duplicate Field Numbers<a href=#duplicate-field-numbers class=hash-link aria-label="Direct link to Duplicate Field Numbers" title="Direct link to Duplicate Field Numbers" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">Error: Duplicate field number 1 in User: name and id</span><br/></div></code></pre></div></div>
<p>Fix: Assign unique field numbers within each message.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=best-practices>Best Practices<a href=#best-practices class=hash-link aria-label="Direct link to Best Practices" title="Direct link to Best Practices" translate=no>​</a></h2>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=project-structure>Project Structure<a href=#project-structure class=hash-link aria-label="Direct link to Project Structure" title="Direct link to Project Structure" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">project/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">├── fdl/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">│   ├── common.fdl       # Shared types</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">│   ├── user.fdl         # User domain</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">│   └── order.fdl        # Order domain</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">├── src/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">│   └── generated/       # Generated code (git-ignored)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">└── build.gradle</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=version-control>Version Control<a href=#version-control class=hash-link aria-label="Direct link to Version Control" title="Direct link to Version Control" translate=no>​</a></h3>
<ul>
<li class=""><strong>Track</strong>: Fory IDL schema files</li>
<li class=""><strong>Ignore</strong>: Generated code (can be regenerated)</li>
</ul>
<p>Add to <code>.gitignore</code>:</p>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain"># Generated Fory IDL code</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">src/generated/</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">generated/</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=cicd-integration>CI/CD Integration<a href=#cicd-integration class=hash-link aria-label="Direct link to CI/CD Integration" title="Direct link to CI/CD Integration" translate=no>​</a></h3>
<p>Always regenerate during builds:</p>
<div class="language-yaml codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-yaml codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token comment" style=color:#999988;font-style:italic># GitHub Actions example</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token key atrule" style=color:#00a4db>steps</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token punctuation" style=color:#393A34>-</span><span class="token plain"> </span><span class="token key atrule" style=color:#00a4db>name</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"> Install Fory IDL Compiler</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token key atrule" style=color:#00a4db>run</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"> pip install ./compiler</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token punctuation" style=color:#393A34>-</span><span class="token plain"> </span><span class="token key atrule" style=color:#00a4db>name</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"> Generate Types</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token key atrule" style=color:#00a4db>run</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"> foryc fdl/</span><span class="token important">*.fdl</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>-</span><span class="token punctuation" style=color:#393A34>-</span><span class="token plain">output src/generated</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token punctuation" style=color:#393A34>-</span><span class="token plain"> </span><span class="token key atrule" style=color:#00a4db>name</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"> Build</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token key atrule" style=color:#00a4db>run</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"> ./gradlew build</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=schema-evolution>Schema Evolution<a href=#schema-evolution class=hash-link aria-label="Direct link to Schema Evolution" title="Direct link to Schema Evolution" translate=no>​</a></h3>
<p>When modifying schemas:</p>
<ol>
<li class=""><strong>Never reuse field numbers</strong> - Mark as reserved instead</li>
<li class=""><strong>Never change type IDs</strong> - They're part of the binary format</li>
<li class=""><strong>Add new fields</strong> - Use new field numbers</li>
<li class=""><strong>Use <code>optional</code></strong> - For backward compatibility</li>
</ol>
<div class="language-protobuf codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-protobuf codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token keyword" style=color:#00009f>message</span><span class="token plain"> User </span><span class="token punctuation" style=color:#393A34>[</span><span class="token annotation">id</span><span class="token operator" style=color:#393A34>=</span><span class="token number" style=color:#36acaa>100</span><span class="token punctuation" style=color:#393A34>]</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>{</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token builtin">string</span><span class="token plain"> id </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token number" style=color:#36acaa>1</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token builtin">string</span><span class="token plain"> name </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token number" style=color:#36acaa>2</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token comment" style=color:#999988;font-style:italic>// Field 3 was removed, don't reuse</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token keyword" style=color:#00009f>optional</span><span class="token plain"> </span><span class="token builtin">string</span><span class="token plain"> email </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token number" style=color:#36acaa>4</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain">  </span><span class="token comment" style=color:#999988;font-style:italic>// New field</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token punctuation" style=color:#393A34>}</span><br/></div></code></pre></div></div>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=troubleshooting>Troubleshooting<a href=#troubleshooting class=hash-link aria-label="Direct link to Troubleshooting" title="Direct link to Troubleshooting" translate=no>​</a></h2>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=command-not-found>Command Not Found<a href=#command-not-found class=hash-link aria-label="Direct link to Command Not Found" title="Direct link to Command Not Found" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">foryc: command not found</span><br/></div></code></pre></div></div>
<p><strong>Solution:</strong> Ensure the compiler is installed and in your PATH:</p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">pip </span><span class="token function" style=color:#d73a49>install</span><span class="token plain"> </span><span class="token parameter variable" style=color:#36acaa>-e</span><span class="token plain"> ./compiler</span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic># Or add to PATH</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token builtin class-name">export</span><span class="token plain"> </span><span class="token assign-left variable environment constant" style=color:#36acaa>PATH</span><span class="token operator" style=color:#393A34>=</span><span class="token environment constant" style=color:#36acaa>$PATH</span><span class="token plain">:~/.local/bin</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=permission-denied>Permission Denied<a href=#permission-denied class=hash-link aria-label="Direct link to Permission Denied" title="Direct link to Permission Denied" translate=no>​</a></h3>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-text codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">Permission denied: ./generated</span><br/></div></code></pre></div></div>
<p><strong>Solution:</strong> Ensure write permissions on the output directory:</p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token function" style=color:#d73a49>chmod</span><span class="token plain"> </span><span class="token parameter variable" style=color:#36acaa>-R</span><span class="token plain"> u+w ./generated</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=import-errors-in-generated-code>Import Errors in Generated Code<a href=#import-errors-in-generated-code class=hash-link aria-label="Direct link to Import Errors in Generated Code" title="Direct link to Import Errors in Generated Code" translate=no>​</a></h3>
<p><strong>Java:</strong> Ensure Fory dependency is in your project:</p>
<div class="language-xml codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-xml codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>dependency</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>groupId</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">org.apache.fory</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>groupId</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>artifactId</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">fory-core</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>artifactId</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token tag punctuation" style=color:#393A34>&lt;</span><span class="token tag" style=color:#00009f>version</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain">${fory.version}</span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>version</span><span class="token tag punctuation" style=color:#393A34>></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token tag punctuation" style=color:#393A34>&lt;/</span><span class="token tag" style=color:#00009f>dependency</span><span class="token tag punctuation" style=color:#393A34>></span><br/></div></code></pre></div></div>
<p><strong>Python:</strong> Ensure pyfory is installed:</p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">pip </span><span class="token function" style=color:#d73a49>install</span><span class="token plain"> pyfory</span><br/></div></code></pre></div></div>
<p><strong>Go:</strong> Ensure fory module is available:</p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">go get github.com/apache/fory/go/fory</span><br/></div></code></pre></div></div>
<p><strong>Rust:</strong> Ensure fory crate is in <code>Cargo.toml</code>:</p>
<div class="language-toml codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-toml codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">[dependencies]</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">fory = "x.y.z"</span><br/></div></code></pre></div></div>
<p><strong>C++:</strong> Ensure Fory headers are in include path.</p>
<p><strong>Dart:</strong> Ensure the fory package is in <code>pubspec.yaml</code>:</p>
<div class="language-yaml codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-yaml codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token key atrule" style=color:#00a4db>dependencies</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token key atrule" style=color:#00a4db>fory</span><span class="token punctuation" style=color:#393A34>:</span><span class="token plain"> ^1.3.0</span><br/></div></code></pre></div></div></div><footer class="theme-doc-footer docusaurus-mt-lg"><div class="row margin-top--sm theme-doc-footer-edit-meta-row"><div class="col noPrint_WFHX"><a href=https://github.com/apache/fory-site/tree/main/docs/compiler/compiler-guide.md target=_blank rel="noopener noreferrer" class=theme-edit-this-page><svg fill=currentColor height=20 width=20 viewBox="0 0 40 40" class=iconEdit_Z9Sw aria-hidden=true><g><path d="m34.5 11.7l-3 3.1-6.3-6.3 3.1-3q0.5-0.5 1.2-0.5t1.1 0.5l3.9 3.9q0.5 0.4 0.5 1.1t-0.5 1.2z m-29.5 17.1l18.4-18.5 6.3 6.3-18.4 18.4h-6.3v-6.2z"/></g></svg>Edit this page</a></div><div class="col lastUpdated_JAkA"></div></div></footer></article><nav class="docusaurus-mt-lg pagination-nav" aria-label="Docs pages"><a class="pagination-nav__link pagination-nav__link--prev" href=/docs/compiler/syntax><div class=pagination-nav__sublabel>Previous</div><div class=pagination-nav__label>Schema IDL</div></a><a class="pagination-nav__link pagination-nav__link--next" href=/docs/compiler/generated_code><div class=pagination-nav__sublabel>Next</div><div class=pagination-nav__label>Generated Code</div></a></nav></div></div><div class="col col--3"><div class="tableOfContents_bqdL thin-scrollbar theme-doc-toc-desktop"><ul class="table-of-contents table-of-contents__left-border"><li><a href=#installation class="table-of-contents__link toc-highlight">Installation</a><ul><li><a href=#from-source class="table-of-contents__link toc-highlight">From Source</a><li><a href=#verify-installation class="table-of-contents__link toc-highlight">Verify Installation</a></ul><li><a href=#command-line-interface class="table-of-contents__link toc-highlight">Command Line Interface</a><ul><li><a href=#basic-usage class="table-of-contents__link toc-highlight">Basic Usage</a><li><a href=#options class="table-of-contents__link toc-highlight">Options</a><li><a href=#scan-generated-files class="table-of-contents__link toc-highlight">Scan Generated Files</a><li><a href=#examples class="table-of-contents__link toc-highlight">Examples</a></ul><li><a href=#import-path-resolution class="table-of-contents__link toc-highlight">Import Path Resolution</a><li><a href=#supported-languages class="table-of-contents__link toc-highlight">Supported Languages</a><li><a href=#output-structure class="table-of-contents__link toc-highlight">Output Structure</a><ul><li><a href=#java class="table-of-contents__link toc-highlight">Java</a><li><a href=#python class="table-of-contents__link toc-highlight">Python</a><li><a href=#go class="table-of-contents__link toc-highlight">Go</a><li><a href=#rust class="table-of-contents__link toc-highlight">Rust</a><li><a href=#c class="table-of-contents__link toc-highlight">C++</a><li><a href=#javascripttypescript class="table-of-contents__link toc-highlight">JavaScript/TypeScript</a><li><a href=#c-1 class="table-of-contents__link toc-highlight">C#</a><li><a href=#swift class="table-of-contents__link toc-highlight">Swift</a><li><a href=#dart class="table-of-contents__link toc-highlight">Dart</a><li><a href=#scala class="table-of-contents__link toc-highlight">Scala</a><li><a href=#kotlin class="table-of-contents__link toc-highlight">Kotlin</a><li><a href=#c-idl-matrix-verification class="table-of-contents__link toc-highlight">C# IDL Matrix Verification</a><li><a href=#swift-idl-matrix-verification class="table-of-contents__link toc-highlight">Swift IDL Matrix Verification</a></ul><li><a href=#build-integration class="table-of-contents__link toc-highlight">Build Integration</a><ul><li><a href=#maven-java class="table-of-contents__link toc-highlight">Maven (Java)</a><li><a href=#gradle-javakotlin class="table-of-contents__link toc-highlight">Gradle (Java/Kotlin)</a><li><a href=#python-setuptools class="table-of-contents__link toc-highlight">Python (setuptools)</a><li><a href=#go-go-generate class="table-of-contents__link toc-highlight">Go (go generate)</a><li><a href=#rust-buildrs class="table-of-contents__link toc-highlight">Rust (build.rs)</a><li><a href=#cmake-c class="table-of-contents__link toc-highlight">CMake (C++)</a><li><a href=#bazel class="table-of-contents__link toc-highlight">Bazel</a><li><a href=#dart--flutter class="table-of-contents__link toc-highlight">Dart / Flutter</a></ul><li><a href=#error-handling class="table-of-contents__link toc-highlight">Error Handling</a><ul><li><a href=#syntax-errors class="table-of-contents__link toc-highlight">Syntax Errors</a><li><a href=#duplicate-type-names class="table-of-contents__link toc-highlight">Duplicate Type Names</a><li><a href=#duplicate-type-ids class="table-of-contents__link toc-highlight">Duplicate Type IDs</a><li><a href=#unknown-type-references class="table-of-contents__link toc-highlight">Unknown Type References</a><li><a href=#duplicate-field-numbers class="table-of-contents__link toc-highlight">Duplicate Field Numbers</a></ul><li><a href=#best-practices class="table-of-contents__link toc-highlight">Best Practices</a><ul><li><a href=#project-structure class="table-of-contents__link toc-highlight">Project Structure</a><li><a href=#version-control class="table-of-contents__link toc-highlight">Version Control</a><li><a href=#cicd-integration class="table-of-contents__link toc-highlight">CI/CD Integration</a><li><a href=#schema-evolution class="table-of-contents__link toc-highlight">Schema Evolution</a></ul><li><a href=#troubleshooting class="table-of-contents__link toc-highlight">Troubleshooting</a><ul><li><a href=#command-not-found class="table-of-contents__link toc-highlight">Command Not Found</a><li><a href=#permission-denied class="table-of-contents__link toc-highlight">Permission Denied</a><li><a href=#import-errors-in-generated-code class="table-of-contents__link toc-highlight">Import Errors in Generated Code</a></ul></ul></div></div></div></div></main></div></div></div><footer class="theme-layout-footer footer footer--dark"><div class="container container-fluid"><div class="row footer__links"><div class="theme-layout-footer-column col footer__col"><div class=footer__title>Community</div><ul class="footer__items clean-list"><li class=footer__item><a href=https://lists.apache.org/list.html?dev@fory.apache.org target=_blank rel="noopener noreferrer" class=footer__link-item>Mailing list<svg width=13.5 height=13.5 aria-label="(opens in new tab)" class=iconExternalLink_nPIU><use href=#theme-svg-external-link /></svg></a><li class=footer__item><a href=https://join.slack.com/t/fory-project/shared_invite/zt-1u8soj4qc-ieYEu7ciHOqA2mo47llS8A target=_blank rel="noopener noreferrer" class=footer__link-item>Slack<svg width=13.5 height=13.5 aria-label="(opens in new tab)" class=iconExternalLink_nPIU><use href=#theme-svg-external-link /></svg></a><li class=footer__item><a href=https://twitter.com/ApacheFory target=_blank rel="noopener noreferrer" class=footer__link-item>Twitter<svg width=13.5 height=13.5 aria-label="(opens in new tab)" class=iconExternalLink_nPIU><use href=#theme-svg-external-link /></svg></a></ul></div><div class="theme-layout-footer-column col footer__col"><div class=footer__title>Docs</div><ul class="footer__items clean-list"><li class=footer__item><a class=footer__link-item href=/docs/start/install>Install</a><li class=footer__item><a class=footer__link-item href=/docs/start/usage>Usage</a><li class=footer__item><a class=footer__link-item href=/docs/introduction/benchmark>Benchmark</a></ul></div><div class="theme-layout-footer-column col footer__col"><div class=footer__title>Repositories</div><ul class="footer__items clean-list"><li class=footer__item><a href=https://github.com/apache/fory target=_blank rel="noopener noreferrer" class=footer__link-item>Apache Fory™<svg width=13.5 height=13.5 aria-label="(opens in new tab)" class=iconExternalLink_nPIU><use href=#theme-svg-external-link /></svg></a><li class=footer__item><a href=https://github.com/apache/fory-site target=_blank rel="noopener noreferrer" class=footer__link-item>Website<svg width=13.5 height=13.5 aria-label="(opens in new tab)" class=iconExternalLink_nPIU><use href=#theme-svg-external-link /></svg></a></ul></div></div><div class="footer__bottom text--center"><div class=margin-bottom--sm><a href=https://apache.org/ rel="noopener noreferrer" class=footerLogoLink_BH7S><img src=/img/asf_logo.svg alt="ASF Logo" class="footer__logo themedComponent_mlkZ themedComponent--light_NVdE" width=200 /><img src=/img/asf_logo.svg alt="ASF Logo" class="footer__logo themedComponent_mlkZ themedComponent--dark_xIcU" width=200 /></a></div><div class=footer__copyright><div>
      <p>
        Copyright © 2026 The Apache Software Foundation, Licensed under the Apache License, Version 2.0. <br/>
        Apache Fory, Fory, Apache, the Apache Logo and the Apache Fory logo are either registered trademarks or trademarks of the Apache Software Foundation in the United States and/or other countries.
      </p>
      </div></div></div></div></footer></div></body>