Fundamentals
SDK
Reference
What's new
Open source project
English
中文 – 简体
中文 – 繁體
Sign in
Contribute to the open source platform
Build Fuchsia
Community
Governance
Fundamentals
SDK
Reference
What's new
Open source project
Build Fuchsia
Community
Governance
Overview
Quickstart
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 NUC using Zedboot (Legacy)
Install Fuchsia on a Khadas VIM3 board
Create a bootable Fuchsia image
Install Fuchsia from a USB flash drive
Set up experimental hardware
Install Fuchsia on Acer Switch Alpha 12
Build and run
Build
Build Workstation
fx workflows
Build and pave quickstart
Retrieve build information
Fuchsia emulator
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
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
Run an example component
Run a test component
Write code
API development
API development overview
Fuchsia API evolution guidelines
Rubrics
API documentation readability rubric
C library readability rubric
Command-line tools rubric
CLI tool help requirements
Dart API readability rubric
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
Assembling Structured Configuration
Component ID index
Migrating legacy components
Overview
Migrate system components
Migrate test components
Component sandbox features
Diagnostics capabilities
Sysmgr configuration
Other common situations
Drivers
Developer guide
Getting started
Write a ramdisk driver
Create a composite node
Driver runtime API guidelines
Drivers rubric
Driver guides
Display drivers
Bringing up a new device
Preparing for new SoCs
Understanding the role of display controllers
USB development
Getting descriptors and endpoints from usb
Concepts
USB system overview
Lifecycle of a USB request
USB mass storage driver
Testing
Overview
Mock DDK
Driver Test Realm
Threading tips in tests
Diagnostics and tools
Inspect
Logging
Tracing
Bind debugger
Driver utilities
Tutorials
Banjo tutorial
Bind tutorial
FIDL tutorial
Bind library code generation tutorial
Best practices
Building a Driver
Driver stack performance
VMO Registration Pattern
Concepts
Getting started
Fuchsia Driver Framework
Device driver model
Overview
Introduction
Device model
Driver binding
Device ops
Device lifecycle
Power management
Device protocol
Platform bus
FIDL
Banjo
Composite devices
Device firmware
Driver architectures
Overview
Input drivers drivers
Fuchsia input drivers
SDMMC drivers
SDMMC driver architecture
Driver development
Overview
Scripting Layer for Fuchsia (SL4F)
Using the C++ DDK template library
PCI Base Address Registers (BAR)
Interrupts
DMA
GPIO initialization
ffx
Overview
Using ffx
Developing for ffx
Overview
Integration testing
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
Dart
Overview
Getting started
FIDL Dart packages
Server
Client
Request pipelining
Examples
Overview
Canvas
Key value store: Baseline example
Key value store: Improving the design
Calculator
Graphics
Escher (Physically-based renderer) concepts
Overview
Building
Flutter (UI toolkit)
Magma (Vulkan driver) concepts
Overview
Design
Test strategy
Vulkan
Porting
Contributing
Scenic (Graphics engine) concepts
Overview
Frame Scheduling
Life of a pixel
Lifecycle of a scene graph resource
Units and metrics
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
Dart
Overview
Analysis
FIDL
IDEs
Logging
Dart style guide
Testing
Third-party Dart packages
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
Realm builder
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
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
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
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
Registering a trace provider
Adding tracing in your code
Recording a Fuchsia trace
Converting and visualizing a trace
Advanced
Tracing asynchronously
Recording a boot trace
Recording a kernel trace
Recording a CPU performance trace
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
Presubmit checks
Gerrit auto-submit
Fuchsia package information using metadata files
README.fuchsia file syntax
Fuchsia archive format (FAR)
Verifying system properties
Build integration
Google celebrates Pride Month.
See how.
Fuchsia
Open source project
Component ID index
Terminology