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

• 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

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

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!

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)

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)

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

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

For detailed build instructions, see CONTRIBUTING.md.

1. Install prerequisites: Rust (nightly) and Godot 4.5+

2. Install CEF binaries:

   cargo install export-cef-dir
   export-cef-dir --version "145.0.26" --force $HOME/.local/share/cef
   export CEF_PATH="$HOME/.local/share/cef"

3. Build:

   cargo xtask bundle --release

4. Copy to Godot project: Copy built artifacts from target/release/ to your project's addons/godot_cef/bin/<platform>/ folder.

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

You can validate bundled addon artifacts with:

cargo xtask validate --addon addons/godot_cef

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.

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.

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

MIT License — Copyright 2025-2026 Delton Ding

See LICENSE for details.

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

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