Godot CEF

Godot CEF

A high-performance Chromium Embedded Framework (CEF) integration for Godot Engine 4.6+, written in Rust. Render web content directly inside your Godot games and applications with full support for modern web standards, JavaScript, HTML5, and CSS3.

Features

• Web Rendering in Godot — Display any web content as a texture using the CefTexture node (extends TextureRect)
• Accelerated Off-Screen Rendering — GPU-accelerated rendering using platform-native graphics APIs for maximum performance
• Software Rendering Fallback — Automatic fallback to CPU-based rendering when accelerated rendering is unavailable
• Dynamic Scaling — Automatic handling of DPI changes and window resizing
• Multi-Process Architecture — Proper CEF subprocess handling for stability and consistency
• Remote Debugging — Built-in Chrome DevTools support
• Typed IPC (CBOR) — Send/receive typed primitives, arrays, and binary buffers (Variant / JS values) without manual JSON serialization
• Listener-based JS Bridge — Multi-subscriber IPC listeners via addListener/removeListener/hasListener
• No-Panic Runtime Policy — Panics in crate runtime code are treated as bugs and blocked by lint/CI policy

Screenshots

GitHub page rendered with full interactivity	Web content integrated into 3D scenes
WebGPU demos running natively	WebGL Aquarium at ~120 FPS with 10,000 fish

Quick Start

Installation

Download the latest pre-built binaries from the Releases page, extract the addon to your Godot project's addons/ folder, and you're ready to go!

Note

During export/package builds, Godot may convert some imported assets into other formats. If your frontend is built with Vite and needs specific source files to remain as-is, you can use vite-plugin-godot-keep-import to keep imports for selected file types.

Basic Usage

extends Control

func _ready():
    var cef_texture = CefTexture.new()
    cef_texture.url = "https://example.com"
    cef_texture.enable_accelerated_osr = true  # Enable GPU acceleration
    add_child(cef_texture)

Example with Signals

extends Node2D

@onready var browser = $CefTexture

func _ready():
    # Set initial URL
    browser.url = "https://example.com"

    # Connect to signals
    browser.load_finished.connect(_on_page_loaded)
    browser.ipc_message.connect(_on_message_received)

func _on_page_loaded(url: String, status: int):
    print("Page loaded: ", url)

    # Execute JavaScript
    browser.eval("document.body.style.backgroundColor = '#f0f0f0'")

func _on_message_received(message: String):
    print("Received from web: ", message)

Documentation

For comprehensive API documentation, examples, and guides, visit the full documentation.

Platform Support

The default/full GitHub Release addon includes Windows x86_64/ARM64, Linux x86_64/ARM64, and macOS universal (x86_64/ARM64). A separate Asset Store addon includes Windows x86_64, Linux x86_64, and the same macOS universal framework to reduce download size. Both packages install as addons/godot_cef; choose one. ARM64 Windows/Linux users should use the full package. See Distribution variants for package names, local packaging commands and source-build instructions.

Limitations

Media Codec Support

The prebuilt CEF binaries do not include proprietary codecs (H.264, AAC, MP3) due to licensing restrictions in the Chromium/CEF stack. This is an upstream limitation that cannot be addressed within this project.

# Convert video to WebM (VP9 + Opus)
ffmpeg -i input.mp4 -c:v libvpx-vp9 -crf 30 -b:v 0 -c:a libopus -b:a 128k output.webm

# Convert video to WebM (AV1 + Opus) - better compression, slower encoding
ffmpeg -i input.mp4 -c:v libaom-av1 -crf 30 -c:a libopus -b:a 128k output.webm

# Convert audio to Opus
ffmpeg -i input.mp3 -c:a libopus -b:a 128k output.ogg

proprietary_codecs=true
ffmpeg_branding=Chrome

Building from Source

For detailed build instructions, see CONTRIBUTING.md.

Quick Build Steps

1. Install prerequisites: mise and Godot 4.6+

2. Install the project toolchain:

   mise trust
   mise install
   

   The commands below assume mise shell integration is active. If your shell is not configured for mise activation yet, prefix commands with mise exec --.

3. Install CEF binaries:

   export CEF_PATH="$HOME/.local/share/cef"
   CEF_VERSION="$(mise run --quiet cef-version)" || exit 1
   export-cef-dir --version "$CEF_VERSION" --force "$CEF_PATH"
   

   mise run cef-version reads the matching CEF runtime version from the cef / cef-dll-sys build metadata in Cargo.lock. The command above uses quiet output and preserves the lockfile while capturing that version.

4. Build:

   mise run bundle --release
   

5. Copy to Godot project: Copy the assembled addons/godot_cef/ directory into your project's addons/ folder.

Build tasks run TypeScript directly with the pinned Node 26. mise run cef-version installs only the small scripts/build package on first use; it does not compile Rust or install the documentation site's dependencies. mise run bundle runs build before assemble. Use mise run assemble with the same flags to assemble existing binaries without invoking Cargo. Rust outputs use target/<triple>/<profile>/ (or --target-dir / CARGO_TARGET_DIR); the macOS universal framework also lives in target/<profile>/Godot CEF.framework.

See the addons/godot_cef/godot_cef.gdextension file for the complete list of required files per platform.

Validate Packaged Addon

You can validate bundled addon artifacts with:

mise run validate --addon addons/godot_cef

No-Panic Policy

This project treats panics in crate runtime code as bugs. We do not use panic-based control flow.

• Workspace lint policy denies panic!, unwrap(), expect(), todo!(), and unimplemented!().
• cargo clippy --workspace --all-targets -- -D warnings is used as a CI gate.
• Release builds use panic = "abort" to prevent unwind-based panic behavior in production artifacts.

If you find a runtime panic path, please open an issue or submit a fix.

Comparison with Similar Projects

Motivation

This project was created during development of Engram. While our first demo version benefited greatly from an interactive UI written in Vue.js using godot_wry, we encountered limitations with the wry-based approach. Since other implementations have long struggled with GPU-accelerated OSR, we decided to create our own solution.

Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines on:

• Setting up your development environment
• Code style and testing requirements
• Pull request process
• Reporting issues

License

MIT License — Copyright 2025-2026 Delton Ding

See LICENSE for details.

Related Repositories

• custom-unit-pxp: A set of packages for the custom pxp unit (px + var) that can be useful for game UI workflows.

Acknowledgments

• godot_wry
• gdcef
• CEF (Chromium Embedded Framework)
• godot-rust
• cef-rs

Star History