Fuchsia
Fundamentals SDK Reference What's new Open source project
  • English
  • 中文 – 简体
  • 中文 – 繁體
Sign in
  • Contribute to the open source platform
Build Fuchsia Community Governance
Fuchsia
  • Fundamentals
  • SDK
  • Reference
  • What's new
  • Open source project
    • Build Fuchsia
    • Community
    • Governance
  • Overview
  • Quickstart
  • Get started with Fuchsia
    • Overview
    • 1. Download the Fuchsia source code
    • 2. Configure and build Fuchsia
    • 3. Start the Fuchsia emulator
    • 4. Explore Fuchsia
  • Set up devices
  • Fuchsia hardware
    • Overview
    • Device setup guides index
    • Install Fuchsia on a NUC
    • Install Fuchsia on a Khadas VIM3 board
  • Fuchsia emulator
    • Fuchsia emulator
  • Build and run
  • Build Fuchsia
    • Build Workbench
    • fx workflows
    • Build and pave quickstart
    • Retrieve build information
    • Advanced
      • Build Clang toolchain
      • Build Rust for Fuchsia
      • Build Fuchsia with custom Rust
      • Run the Rust test suite
      • Run Clang static analysis
      • Ninja no-op check
      • How Ninja works
      • Fuchsia-specific Ninja improvements
      • Hermetic actions check
    • Build system
      • Overview
      • Fuchsia build system
      • Boards and products
        • Overview
        • Bringup Product Definition
      • Build system policies
      • GN
        • Introduction to GN
        • Bundles
        • Variants
        • GN template best practices
        • GN toolchain best practices
      • Build system internals
        • Overview
        • Manifest file formats
        • GN toolchains and the Fuchsia build
          • GN toolchains overview
          • ELF shared library redirection
          • Build variants
  • Run components
    • Run an example component
    • Run a test component
  • Write code
  • API development
    • API development overview
    • Fuchsia API evolution guidelines
    • Rubrics
      • API documentation readability rubric
      • Bind library guidelines
      • C library readability rubric
      • Command-line tools rubric
      • CLI tool help requirements
      • Developer tool guidelines
      • FIDL API readability rubric
      • Go rubric
      • Rust rubric
      • Zircon system interface rubric
  • Audio
    • Loudness
    • Drivers
      • Overview
      • Architecture
      • Audio driver streaming interface
      • Audio Signal Processing
      • Digital Audio Interface (DAI)
      • Audio codec
      • Audio composite
  • Bluetooth
    • Concepts
      • Bluetooth architecture
      • Bluetooth persistent data schema
  • Boards
    • Adding support for new boards
  • Components
    • Overview
    • Build components
    • Connect components
    • Run components
    • Provide data files to components
    • Configure components
      • Overview
      • Config-data package
      • Structured Configuration
      • Evolving Structured Configuration
      • Assembling Structured Configuration
    • Component ID index
  • Drivers
    • Overview
    • DFv1 to DFv2 driver migration
      • Overview
      • 1. Migrate from Banjo to FIDL
      • 2. Migrate from DFv1 to DFv2
    • DFv2 driver development
      • Composite nodes
      • Driver stack performance
      • VMO Registration Pattern
      • DMA
      • Tutorials
        • Bind rules tutorial
        • Bind library code generation tutorial
        • FIDL tutorial
      • Testing
        • DriverTestRealm
        • Threading tips in tests
      • Debugging
        • Driver utilities
      • Driver runtime API guidelines
      • Drivers rubric
    • DFv1 driver development
      • Fuchsia driver development (DFv1)
      • Building a Driver
      • Interrupts
      • Platform Bus
      • Tutorials
        • Banjo tutorial
        • Using the C++ DDK template library
      • Testing
        • Driver testing
        • Mock DDK
      • Debugging
        • Using Inspect for drivers
        • Driver Logging
        • Add tracing to a driver
    • DFv1 concepts
      • Fuchsia Driver Framework (DFv1)
      • Device driver model
        • Overview
        • Introduction
        • Device model
        • Driver binding
        • The Device ops
        • Device driver lifecycle
        • Device power management
        • Protocols in drivers
        • FIDL in drivers
        • Banjo in drivers
        • Composite devices
        • Device firmware
    • Driver-specifc guides
      • Board drivers
        • GPIO initialization
      • Display drivers
        • How to write a display driver
        • Modifying board drivers
        • What does a display controller do?
      • PCI drivers
        • Configuration
      • Registers
        • Registers overview
      • USB drivers
        • Getting descriptors and endpoints from USB
        • USB system overview
        • Lifecycle of a USB request
        • USB mass storage driver
      • Input drivers
        • Fuchsia input drivers
        • Input report reader library
      • SDMMC drivers
        • SDMMC drivers architecture
    • Others
      • Deleting drivers
  • ffx
    • Overview
    • Using ffx
    • Developing for ffx
      • Overview
      • Integration testing
        • Overview
        • Testing utility library
      • Developing an FFX subtool
      • Experimental subtools
      • Subtool writers
      • Migrating plugins to Subtools
      • Handling errors in subtools
      • Developing legacy plugins (deprecated)
      • Legacy plugin internals (deprecated)
      • Legacy experimental plugins (deprecated)
    • Commands
      • Config
      • Log
      • Selecting components
    • Architecture
      • CLI
      • FHO subtool interface
  • FIDL
    • Overview
    • Developer guide
      • Overview
      • Running FIDL
      • Style guide
      • Designing APIs
      • Maxing out pagination
      • Picking between LLCPP and HLCPP bindings
      • Viewing generated bindings code
      • Editor Support
      • Hanging Gets in Rust
    • Compatibility guide
      • Overview
      • Change a bits from flexible to strict
      • Add a bits member
      • Remove a bits member
      • Change a bits from strict to flexible
      • Change an enum from flexible to strict
      • Add an enum member
      • Remove an enum member
      • Change an enum from strict to flexible
      • Add a protocol event
      • Remove a protocol event
      • Add a protocol method
      • Remove a protocol method
      • Add a table member
      • Remove a table member
      • Change a union from flexible to strict
      • Add union member
      • Remove union member
      • Change a union from strict to flexible
    • Tutorials
      • Overview
      • Compiling FIDL
      • New C++ bindings
        • Overview
        • Getting started
          • Natural and wire domain objects
          • Server
          • Async client
          • Sync client
        • Memory ownership of wire domain objects
        • Responding asynchronously
        • Thread safety and memory safety
        • Communicating over the driver transport
        • Request pipelining
        • Services
      • HLCPP (Old)
        • Overview
        • Getting started
          • Compiling HLCPP
          • Server
          • Async client
          • Sync client
        • Debug output
        • Serving multiple clients
        • Request pipelining
        • Services
        • Testing protocols
      • Rust
        • Overview
        • Getting started
          • FIDL Rust Crates
          • Server
          • Async client
          • Sync client
        • Request pipelining
        • Services
    • Examples
      • Overview
      • Canvas
      • Key value store: Baseline example
      • Key value store: Improving the design
      • Calculator
  • Graphics
    • Escher (Physically-based renderer) concepts
      • Overview
      • Building
    • Magma (Vulkan driver) concepts
      • Overview
      • Design
      • Test strategy
      • Vulkan
      • Porting
      • Contributing
    • Scenic (Graphics engine) concepts
      • Overview
      • Frame Scheduling
      • Life of a pixel
      • Views, bounds, and clipping
      • Scenic Views, view tree, and ViewRefs
      • Scenic Views, view focus, and focus chain
    • Sysmem (Shared memory manager) concepts
      • Overview
      • VMO hierarchy
  • IDK
    • IDK
    • Download the Fuchsia IDK
    • IDK layout
    • IDK standards
    • Using the Core IDK
      • Integrating the IDK into your build environment
      • Understanding IDK metadata
      • "Core" IDK Documentation
      • Bootserver
      • Compilation
      • Debugger
      • Devices
      • Logging
      • Packages
      • SSH
  • Internationalization
    • Overview
    • ICU
    • ICU data
    • Internationalization preferences
    • Fonts
      • Fonts
      • Build configuration
      • Font provider service
      • Maintenance tasks
    • Localization
      • Localization
      • Message translation
      • Lookup API
      • Locale fallback
      • Localization workflow
      • Packaging
      • Future work
    • Future work
  • Kernel
    • Getting started
    • Kernel in the build
    • Manage memory
      • Memory usage analysis tools
      • Out of memory system
    • Manage threads
      • Thread safety annotations
      • Thread local storage
    • Object usage analysis tools
    • Cross translation unit static analysis in Zircon
    • Time units
    • Notes on kernel development
  • Languages
    • Overview
    • Configure linters and formatter
    • Fuchsia endian policy
    • Support new languages
      • Overview
      • Recommended structure to support Fuchsia
    • C/C++
      • Overview
      • Editor setup
      • Naming conventions
      • C++ style guide
      • Lint
      • Libc support
      • Library restrictions
      • Logging
      • Perftest micro-benchmark library
      • C++ in Zircon
      • Compile time collections
      • fpromise::promise<> guide
      • fbl:: (Fuchsia Base Library) intrusive container guide
        • Introduction to fbl intrusive containers
        • Getting started
        • Controlling container membership
        • Sequenced containers
        • Associative containers
        • Iterators
        • Testing an object for membership in a container
        • Lifecycle checks
        • size()'s order of operation
        • Advanced scenarios
      • Thread safe asynchronous code
    • Go
      • Overview
      • Logging
      • Readability reviews
    • Python
      • Overview
      • Python style guide
      • Testing
    • Rust
      • Overview
      • Learn Rust
      • FIDL Rust crates
      • Rust editor configurations
      • Using cargo on Fuchsia
      • Logging
      • Ergonomic Inspect
      • Testing Rust Code
      • Measuring Rust Binary Bloat
      • External Rust crates
      • External Rust crate Reviews
      • Unsafe code in Rust
      • Running tests in miri
      • Unstable Rust features
      • Integrating C/C++ using bindgen
  • Networking
    • Concepts
      • Telephony
      • Wireless
  • Sessions
    • Building and running a session
    • Writing a Hello World session
    • Session roles and responsibilities, by example
  • Settings
    • Introduction
    • Policy concepts
    • Using Settings
  • UI-Input
    • Flatland scene dump
    • Tracing input events
    • Life of a touch event
    • Magnification
  • Virtualization
    • Concepts
    • Get Started
  • Test and debug
  • Test
    • Run Fuchsia tests
    • Testing Scenic and Escher
    • Questions and answers
    • Zircon testing
      • Zircon testing overview
      • Block device testing
      • NAND testing
    • Compatibility Testing
      • Overview
      • Introduction
      • Contributing
        • Contributing Tests
        • CTF Test Realm
        • Testing Guidelines
        • Diagnosing Test Failures
      • Platform Surface Area (Plasa)
        • Overview
        • Plasa manifest
      • FIDL API Compatibility Testing
      • Frequently Asked Questions
    • Component testing
      • Overview
      • Test components
      • Test Runner Framework
      • Integration testing
      • Test realm factory
      • Realm builder
      • Create Test Realm
    • Driver testing
      • Testing a USB device
    • Fuzzing
      • Overview
      • Write a Fuzzer
      • Build a Fuzzer
      • Run a Fuzzer
      • Handling Results Found Through Fuzzing
      • Improving Your Fuzzer
        • Overview
        • Additional Topics
    • Host-target interaction tests
    • Scripting Layer for Fuchsia (SL4F)
    • Testing for flakiness in CQ
    • Flaky test policy
    • Stress tests
    • Rust stress test library
    • Bluetooth
      • Writing unit tests for the C++ bt-host driver
    • Testability rubrics
    • Hardware testing guide
    • Testing Third Party Changes
  • Diagnose
    • Inspect
      • Overview
      • Quickstart
      • Health
      • Rust libraries
      • Inspect codelab
        • Overview
        • Codelab
      • Using Inspect for drivers
    • Log
      • Overview
      • Record
      • Choose severity
      • View
      • Logging and tests
    • Analytics Platform
      • Detect snapshot filing
      • Diagnostics Persistence Service
      • Sampler - Diagnostics Data Forwarder
    • Analyze with Triage
      • Overview
      • Configuring Triage
      • Codelab
      • Triage (fx triage)
    • Diagnostics and Testing Workshop
      • Overview
      • Codelab
    • Error codes
      • Troubleshoot zx_err_peer_closed
  • Performance testing
    • How to run performance tests
    • Use cases for performance tests
    • Perfcompare: Try builder for pre-submit testing
    • Viewing Zircon microbenchmarks with Chromeperf
    • Fuchsiaperf format for performance test results
    • Fuchsiaperf producers: libraries
    • Fuchsiaperf consumers: analysis tools
    • Naming style for metrics
    • Metric name expectation files
    • Documenting performance tests
    • Chromeperf uploading and config
    • FAQ
  • Debug
    • Debugging workflow
    • Packet capture
    • Just In Time Debugging
    • UI debugging tips
    • Use the native debugger (zxdb)
      • zxdb: The Fuchsia debugger
      • Set up and run the debugger
      • Commands and interaction model
      • Debugging a process, component, or crash dump
      • Controlling thread execution
      • Using breakpoints
      • Evaluating and printing expressions
      • Inspecting memory
      • Working with assembly language
      • Looking at handles
      • Diagnosing symbol problems
      • Working with exceptions
      • Developing and debugging the debugger
    • Debug the kernel
      • Debug the kernal using QEMU
      • JTRACE
      • Kernel debugging tips
    • Advanced
      • ACPI debugging
  • Monitoring
    • fidlcat
      • Overview
      • Guide
  • Trace
    • Overview
    • Tutorial
      • Overview
      • 1. Register a trace provider
      • 2. Add tracing in your code
      • 3. Record and visualize a trace
    • Advanced
      • Tracing asynchronously
      • Recording a boot trace
      • Recording a kernel trace
      • Recording a CPU performance trace
  • Fuchsia Controller
    • Fuchsia Controller tutorial
  • Publish and deploy
  • Prebuilt packages
    • Overview
    • Publish prebuilt packages to CIPD
    • Publish a CIPD symbols package for ELF binaries
    • Make your CIPD package visible to Fuchsia developers
  • Contribute code
  • Contribute source code
    • Contribute source changes
    • Workflow tips and FAQ
    • Upload changes from multiple repositories
    • Make changes across different petals
    • Source code layout
    • Owners
    • Static analyzers
    • Presubmit checks
    • Gerrit auto-submit
    • Fuchsia package information using metadata files
    • README.fuchsia file syntax
    • Fuchsia archive format (FAR)
    • Third-party source code management
  • Verifying system properties
    • Build integration
  • Fuchsia
  • Open source project

Guide to bringing a new language to Fuchsia

Fuchsia is designed to support a wide variety of languages. This directory contains documentation about how to bring a new language to Fuchsia.

Topics

  • How to structure Fuchsia support for a language
  • Fuchsia System Interface
bug_report code edit

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates.

Last updated 2023-10-19 UTC.

  • Terms
  • Privacy
  • English
  • 中文 – 简体
  • 中文 – 繁體