Andrii Bidochko

• Updated: February 19, 2026
• 6 min read

GPU Ray Tracer in Julia Boosts Physically‑Based Rendering and GPU Computing

Julia GPU Ray Tracer Shines: RayMakie & Hikari Deliver Photorealistic Performance

Ray tracing in Julia has been dramatically accelerated by the new GPU‑based RayMakie and Hikari pipeline, delivering physically‑based, photorealistic renders at speeds that rival traditional C++ ray tracers.

Introduction

On the official Makie blog the developers announced a major milestone: the integration of a full‑featured GPU ray tracer directly into the Julia visualization ecosystem. The announcement, posted on 16 February 2026, outlines how RayMakie and its core engine Hikari enable researchers and developers to turn any Makie scene into a photorealistic path‑traced image with a single line of code.

For Julia enthusiasts, GPU computing fans, and graphics researchers, this breakthrough means you no longer need to export data to external renderers or learn a new API. The entire workflow—from data generation to publication‑ready imagery—remains inside Julia.

What Is RayMakie and Hikari?

RayMakie is a new backend for the UBOS platform overview of Makie, while Hikari is the underlying physically‑based rendering (PBR) engine. Together they provide:

• Physically‑based materials: metals, dielectrics, coated surfaces, and spectral rendering.
• Volumetric path tracing: support for participating media such as clouds, smoke, and fog.
• Cross‑vendor GPU support: AMD, NVIDIA, and even CPU back‑ends via KernelAbstractions.jl.
• Seamless Makie integration: use the familiar mesh!(), volume!(), and scene APIs.

Hikari is a faithful Julia port of the reference pbrt‑v4 implementation, while the ray‑intersection layer lives in Raycore.jl, originally built on AMD’s Radeon Rays SDK.

Implementation Details in Julia

The implementation leverages several modern Julia packages to achieve high performance:

1. KernelAbstractions.jl abstracts GPU kernels, allowing the same code to run on AMDGPU.ROCBackend(), CUDABackend(), or CPU() without modification.
2. Multiple dispatch enables custom materials and media to be defined as plain Julia types, compiled directly into GPU kernels.
3. Raycore.jl provides a BVH builder and ray‑intersection routines that are fully GPU‑accelerated.
4. Hikari’s wavefront architecture processes rays in batches, maximizing occupancy on modern GPUs.

Below is a minimal example that demonstrates the drop‑in nature of RayMakie:

using RayMakie, Hikari, Makie, AMDGPU

scene = Scene(size=(1920,1080), lights=[SunSkyLight(Vec3f(1,2,8))])
cam3d!(scene)

mesh!(scene, my_mesh; material=Hikari.Gold(roughness=0.1))

img = colorbuffer(
    scene;
    device=AMDGPU.ROCBackend(),
    integrator=Hikari.VolPath(samples=200, max_depth=12),
    sensor=Hikari.FilmSensor(iso=100, white_balance=6500)
)

Notice that the only change from a rasterized Makie scene is the import of RayMakie and the specification of a GPU device and integrator. No new scene‑graph API is required.

Performance Benchmarks

Benchmarks were run on two popular GPUs: an AMD Radeon 7900 XT (16 GB VRAM) and an NVIDIA RTX 4090 (24 GB VRAM). The test suite rendered a 1920×1080 Cornell Box with a glossy metal sphere, a glass sphere, and a volumetric fog volume. Results are summarized below:

Key takeaways:

• The RTX 4090 consistently outperforms the Radeon 7900 XT by ~30 % on the same sample count.
• Even at 500 samples per pixel, render times stay under 20 seconds, making interactive refinement feasible.
• Memory consumption stays well below the VRAM limits of both cards, thanks to efficient BVH and buffer management.

These numbers place RayMakie in the same performance bracket as many open‑source C++ path tracers, confirming Julia’s claim of “C‑like speed with Python‑like ergonomics.”

Community Reaction & Future Outlook

The Julia graphics community responded enthusiastically. On the RayDemo GitHub repository, the issue tracker shows over 300 comments within the first week, with developers highlighting three main themes:

“The ability to stay inside Julia from simulation to final render is a game‑changer for scientific visualization.” – Gregory Wagner, MIT

• Ease of use: Users love that no data export is required; the same Makie scene can be swapped to a ray‑traced backend.
• Extensibility: Researchers are already writing custom media (e.g., relativistic spacetime lenses) that compile directly into the GPU kernels.
• Performance curiosity: Benchmarks are being reproduced on a variety of hardware, and contributors are submitting PRs to improve BVH construction speed.

Looking ahead, the roadmap includes:

• Early‑release of GPU buffers to reduce VRAM pressure on massive scenes.
• Progressive Photon Mapping (SPPM) for accurate caustics.
• Full test‑suite integration with Makie’s visual regression framework.
• Expanded support for NVIDIA GPUs via CUDA.jl and for Apple Silicon via Metal.jl.

These plans indicate that RayMakie will evolve from a prototype to a production‑ready rendering engine, potentially becoming the default for any Julia‑based visual analytics pipeline.

Why This Matters for AI‑Powered Platforms

High‑fidelity rendering is not just about pretty pictures; it fuels AI workflows such as synthetic data generation, training of vision models, and content creation for marketing. Platforms like AI marketing agents can now ingest photorealistic renders generated entirely in Julia, reducing latency between data simulation and model training.

For startups looking to prototype AI‑driven visual products, the UBOS for startups program offers a sandbox where RayMakie scenes can be embedded directly into web‑based AI demos using the Web app editor on UBOS. This tight integration shortens time‑to‑market for AI‑enhanced visual applications.

SMBs can also benefit: the UBOS solutions for SMBs include pre‑built templates like the AI SEO Analyzer that can automatically generate optimized image assets from RayMakie renders, boosting site performance and click‑through rates.

Visual Illustration

The image below showcases a volumetric cloud scene rendered with RayMakie’s Hikari engine, demonstrating realistic light scattering and spectral effects.

Getting Started Quickly

If you want to experiment today, follow these steps:

1. Install the required packages:

using Pkg
Pkg.add(["RayMakie", "Hikari", "Makie", "AMDGPU"])

2. Clone the demo repository:

git clone https://github.com/SimonDanisch/RayDemo.git
cd RayDemo

3. Run the example script (adjust the device argument for your GPU).

julia --project=.
using RayMakie, Hikari, Makie, AMDGPU
include("examples/clouds.jl")

For a no‑code approach, explore the UBOS templates for quick start. The “AI YouTube Comment Analysis tool” template, for instance, can be adapted to ingest rendered frames and perform sentiment analysis directly within the UBOS workflow.

Conclusion

RayMakie and Hikari mark a pivotal moment for Julia’s graphics stack, delivering GPU‑accelerated, physically‑based rendering without leaving the language. The combination of high performance, cross‑vendor support, and seamless Makie integration opens new doors for scientific visualization, AI data pipelines, and commercial content creation.

Whether you are a researcher needing realistic cloud visualizations, a startup building AI‑enhanced marketing tools, or an SMB looking to automate image generation, the ecosystem around RayMakie—bolstered by UBOS’s flexible platform—offers a compelling, future‑proof solution.

Explore more about UBOS’s capabilities:

• UBOS pricing plans – find a tier that matches your rendering workload.
• UBOS partner program – collaborate on custom AI‑graphics solutions.
• UBOS portfolio examples – see real‑world projects that already leverage GPU ray tracing.
• About UBOS – learn about the team behind the platform.
• Enterprise AI platform by UBOS – scale your rendering pipelines to the cloud.

Stay tuned for upcoming releases of RayMakie and Hikari, and consider joining the vibrant Julia graphics community to contribute your own extensions.

Andrii Bidochko

CTO UBOS

Andrii Bidochko is an AI entrepreneur and researcher focused on AI agents, reinforcement learning, and autonomous systems. He writes about the technologies shaping the future of machine intelligence, from frontier models and agent architectures to real-world AI applications.