ernie-renderer 0.2.0.dev70__tar.gz → 0.2.0.dev76__tar.gz

ernie_renderer-0.2.0.dev76/.pre-commit-config.yaml

@@ -0,0 +1,45 @@
+# Vendored sources stay byte for byte as their upstream release.
+exclude: ^third_party/[^/]+/
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-added-large-files
+      - id: check-merge-conflict
+      - id: check-case-conflict
+      - id: check-yaml
+      - id: mixed-line-ending
+        args: ["--fix=lf"]
+
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: v23.1.3
+    hooks:
+      - id: clang-format
+        types_or: [c++, c]
+        # Data tables written by tools/, kept exactly as generated.
+        exclude: _table\.h$
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.17.1
+    hooks:
+      - id: ruff-check
+        args: [--fix]
+      - id: ruff-format
+
+  - repo: https://github.com/BlankSpruce/gersemi-pre-commit
+    rev: 0.29.2
+    hooks:
+      - id: gersemi
+
+  # Every source file of Ernie's own starts with its license line.
+  - repo: local
+    hooks:
+      - id: spdx-license
+        name: SPDX license line
+        language: pygrep
+        entry: "SPDX-License-Identifier: BSD-3-Clause"
+        args: [--negate]
+        files: (\.(cpp|h|slang|py|cmake|sh)|(^|/)CMakeLists\.txt)$

ernie_renderer-0.2.0.dev76/CMakeLists.txt

@@ -0,0 +1,114 @@
+# SPDX-License-Identifier: BSD-3-Clause
+cmake_minimum_required(VERSION 3.21)
+# Extracted downloads get the time they were extracted, so they rebuild when they change.
+if(POLICY CMP0135)
+    cmake_policy(SET CMP0135 NEW)
+endif()
+
+project(
+    Ernie
+    VERSION 0.2.0
+    DESCRIPTION
+        "Efficient Renderer for Natural and Interplanetary Environments: a spectral Vulkan ray tracer"
+    HOMEPAGE_URL "https://github.com/alexmaietta/ernie"
+    LANGUAGES C CXX
+)
+
+# Pre-release suffix such as .dev12, written by CI.
+set(ERNIE_VERSION_SUFFIX ".dev76" CACHE STRING "Pre-release suffix of Ernie's version")
+set(ERNIE_VERSION "${PROJECT_VERSION}${ERNIE_VERSION_SUFFIX}")
+
+option(ERNIE_BUILD_TESTS "Build Ernie's tests" OFF)
+option(ERNIE_BUILD_BENCHMARKS "Build Ernie's benchmarks" OFF)
+option(ERNIE_BUILD_PYTHON "Build Ernie's Python module" ${PROJECT_IS_TOP_LEVEL})
+option(ERNIE_BUILD_APP "Build the ernie program" ON)
+option(ERNIE_WARNINGS_AS_ERRORS "Treat compiler warnings as errors" OFF)
+option(ERNIE_ASSERTS "Keep assertions in optimised builds" OFF)
+option(ERNIE_TRACY "Send profiling zones to the Tracy profiler too" OFF)
+option(ERNIE_COVERAGE "Instrument Ernie for code coverage (GCC or Clang)" OFF)
+option(ERNIE_INSTALL "Install libernie for C++ consumers" ${PROJECT_IS_TOP_LEVEL})
+
+set(CMAKE_INSTALL_DOCDIR "share/doc/ernie" CACHE PATH "Documentation and licences")
+include(GNUInstallDirs)
+
+get_property(ernie_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if(PROJECT_IS_TOP_LEVEL AND NOT ernie_multi_config AND NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Build type" FORCE)
+endif()
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
+# Every object goes into the shared library too, and only its public API leaves it: symbols are
+# hidden unless marked ERNIE_API, including those of the dependencies built here.
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
+
+include(cmake/ErnieFetch.cmake)
+include(cmake/third_party/openexr.cmake)
+include(cmake/third_party/tracy.cmake)
+include(cmake/third_party/slang.cmake)
+add_subdirectory(third_party)
+
+add_library(ernie_build_options INTERFACE)
+# All of Ernie's own code is built as the shared library's (ernie_EXPORTS), so ERNIE_API exports
+# there and is harmless in the static library. glm's configuration stays inside Ernie: it changes
+# no layout, but consumers' own glm calls must not see it.
+target_compile_definitions(ernie_build_options INTERFACE ernie_EXPORTS GLM_FORCE_DEPTH_ZERO_TO_ONE)
+if(MSVC)
+    target_compile_options(ernie_build_options INTERFACE /W4 /permissive- /Zc:__cplusplus /utf-8)
+    # The CRT's "unsafe function" deprecations (getenv, fopen) would fail warnings-as-errors builds.
+    target_compile_definitions(
+        ernie_build_options
+        INTERFACE NOMINMAX WIN32_LEAN_AND_MEAN _CRT_SECURE_NO_WARNINGS
+    )
+else()
+    target_compile_options(
+        ernie_build_options
+        INTERFACE
+            -Wall
+            -Wextra
+            -Wpedantic
+            -Wshadow
+            -Wconversion
+            -Wsign-conversion
+            # Designated initializers leave Vulkan structs' other fields zero by design.
+            -Wno-missing-field-initializers
+    )
+endif()
+if(ERNIE_WARNINGS_AS_ERRORS)
+    target_compile_options(ernie_build_options INTERFACE $<IF:$<CXX_COMPILER_ID:MSVC>,/WX,-Werror>)
+endif()
+if(ERNIE_ASSERTS)
+    target_compile_options(
+        ernie_build_options
+        INTERFACE $<IF:$<CXX_COMPILER_ID:MSVC>,/UNDEBUG,-UNDEBUG>
+    )
+endif()
+if(ERNIE_COVERAGE)
+    target_compile_options(ernie_build_options INTERFACE --coverage -fprofile-update=atomic -Og -g)
+    target_link_options(ernie_build_options INTERFACE --coverage)
+endif()
+
+add_subdirectory(ernie)
+if(ERNIE_INSTALL)
+    include(cmake/ErnieInstall.cmake)
+endif()
+
+if(ERNIE_BUILD_TESTS)
+    enable_testing()
+    add_subdirectory(tests)
+endif()
+if(ERNIE_BUILD_BENCHMARKS)
+    add_subdirectory(benchmarks)
+endif()
+
+if(PROJECT_IS_TOP_LEVEL AND NOT SKBUILD)
+    include(cmake/ErniePackaging.cmake)
+endif()

ernie_renderer-0.2.0.dev76/Dockerfile

@@ -0,0 +1,25 @@
+# SPDX-License-Identifier: BSD-3-Clause
+FROM ubuntu:24.04 AS build
+ARG DEBIAN_FRONTEND=noninteractive
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends ca-certificates cmake g++ git ninja-build python3-dev \
+    && rm -rf /var/lib/apt/lists/*
+WORKDIR /src
+COPY . .
+RUN cmake -S . -B /build -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/opt/ernie \
+    && cmake --build /build \
+    && cmake --install /build --component app \
+    && cmake --install /build --component runtime
+
+FROM ubuntu:24.04
+ARG DEBIAN_FRONTEND=noninteractive
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends libvulkan1 mesa-vulkan-drivers \
+    && rm -rf /var/lib/apt/lists/*
+COPY --from=build /opt/ernie/bin/ernie /usr/local/bin/ernie
+# Data and the licences of everything the program carries.
+COPY --from=build /opt/ernie/share /usr/local/share
+ENV NVIDIA_DRIVER_CAPABILITIES=graphics,compute,utility
+WORKDIR /work
+ENTRYPOINT ["ernie"]
+CMD ["--help"]

ernie_renderer-0.2.0.dev76/PKG-INFO

@@ -0,0 +1,230 @@
+Metadata-Version: 2.4
+Name: ernie-renderer
+Version: 0.2.0.dev76
+Summary: Efficient Renderer for Natural and Interplanetary Environments: a physically based, spectral Vulkan ray tracer
+Author: Alex Maietta
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Project-URL: Homepage, https://github.com/alexmaietta/ernie
+Project-URL: Repository, https://github.com/alexmaietta/ernie
+Project-URL: Issues, https://github.com/alexmaietta/ernie/issues
+Requires-Python: >=3.10
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Description-Content-Type: text/markdown
+
+> 🚧 **This project is in active beta development.** This means the API is unstable, features may be added or removed, and breaking changes are likely to occur frequently and without notice as the design is refined.
+
+[![CI](https://github.com/alexmaietta/ernie/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/alexmaietta/ernie/actions/workflows/ci.yml)
+[![Coverage](https://img.shields.io/endpoint?url=https%3A%2F%2Falexmaietta.github.io%2Fernie%2Fcoverage%2Fbadge.json)](https://alexmaietta.github.io/ernie/coverage/)
+[![Release](https://img.shields.io/github/v/release/alexmaietta/ernie?include_prereleases&sort=semver&color=orange)](https://github.com/alexmaietta/ernie/releases)
+[![PyPI](https://img.shields.io/pypi/v/ernie-renderer?color=3775A9&logo=pypi&logoColor=white)](https://pypi.org/project/ernie-renderer/)
+[![Docs](https://img.shields.io/badge/docs-latest-8A2BE2)](https://alexmaietta.github.io/ernie/)
+[![License](https://img.shields.io/badge/license-BSD--3--Clause-2E8B57)](LICENSE)
+
+# Efficient Renderer for Natural and Interplanetary Environments (Ernie)
+
+![]()
+
+Ernie is a physically accurate, real-time, spectral renderer for interplanetary environments.
+
+It is a Vulkan ray tracer for Linux, Windows and macOS (through MoltenVK), with C++ and Python APIs and a Hydra-like scene API. Ernie is designed around physical quantities, efficient batched rendering, and interoperability.
+
+Ernie is built to be extensible, customizable, and to work alongside other tools. You can add your own BRDFs, sensor filters and light patterns. Rendered outputs and scene attributes (transforms, mesh vertices, light parameters and more) are shared zero copy with any DLPack tensor (PyTorch, JAX, Warp, NumPy), which makes Ernie a good fit for real-time physics simulation and reinforcement learning. Support for OpenUSD and glTF scenes, and for MDL and MaterialX materials, is planned.
+
+Its key features are aimed at planetary robotics and sensing:
+
+- **Spectral light**
+    - Light carried in bands (16 across 380-780 nm by default, up to 64 into the infrared) from the source, through materials and media, to the sensor
+    - Sun, sky, lamps, domes and lasers in physical units, with measured spectra such as the TSIS-1 sun
+    - Distant lights as limb-darkened discs whose angular size sets every penumbra
+- **Planets and space**
+    - Terrain and whole planets with continuous level of detail from orbit to the ground, their heights and maps streamed from rasters larger than GPU memory
+    - Adaptive spheres and ellipsoids, exact from a pebble to a star, in double precision with a floating origin and reverse-Z depth
+    - Earth and Mars atmospheres from physical models, with refraction, seen from the ground or from orbit
+    - Eclipses cast by real geometry, and star fields from your own catalogues
+- **Materials**
+    - Planetary photometry with Hapke, Lommel-Seeliger and lunar-Lambert, with parameters from texture maps
+    - OpenPBR Surface and UsdPreviewSurface, spectral throughout
+    - Your own BRDFs written in Slang
+- **Cameras and sensors**
+    - Perspective, fisheye, orthographic and line-scan pushbroom cameras, with CAHVORE and USGS CSM instrument models
+    - The EMVA 1288 sensor model: quantum efficiency, shot and read noise, dark current, PRNU, DSNU, full well and ADC
+    - Filter chains for optics and detectors (diffraction, lens flare, blooming, smear, TDI, Bayer, companding), with your own in Slang
+    - Polarization cameras
+- **Thermal infrared**
+    - Planck emission from surfaces and volumes, with emissivity from Kirchhoff's law or measured spectra
+    - Temperatures from your own solver, textures, or models run per pixel: spacecraft energy balance and diurnal tables for airless bodies
+    - Microbolometer cameras with NETD, fixed pattern noise and false-colour palettes
+- **Volumes**
+    - Smoke, dust, exhaust plumes and clouds from VDB files or GPU arrays, ray marched spectrally and casting shadows
+    - Procedural cloud layers, with Mie droplets for silver linings, fogbows and glories
+- **Lasers and structured light**
+    - Gaussian beams and diffractive patterns (lines, grids, dot fields or your own), pulses, speckle, and beams seen in dust and air
+- **Simulation and learning**
+    - Thousands of worlds and cameras rendered in one batched step for RL and Monte Carlo workloads
+    - Inputs and outputs shared without copies with PyTorch, JAX, Warp and NumPy, through CUDA and HIP
+    - Columns and incremental sync: thousands of prims' poses written in one call, and an edit redraws only what it reaches
+- **Tools and integrations**
+    - A viewer with your own panels and debug drawing, and C++ and Python APIs on Linux, Windows and macOS
+    - OpenUSD import, renderer backends for Newton Viewer, IsaacLab and Chrono::Sensor, and TerrainGen built on the viewer
+
+For a more detailed overview of the features, see our [documentation](https://alexmaietta.github.io/ernie/).
+
+Future work:
+
+- A fully USD- and glTF-compliant renderer, loading OpenUSD, glTF, OBJ, STL and 3D Tiles, with the glTF material system, UsdPreviewSurface shaders and MDL and MaterialX support
+- Differentiable rendering
+- Reflections and global illumination
+- OpenXR integrations
+- WebGPU backend
+- Gaussian splat and particle fields
+- Lidar and radar sensors
+- A real-time ray-tracing renderer alongside the rasterizer
+- Integrations into Newton Viewer, Chrono Sensor, and IsaacLab
+- Benchmark against RTX, Cycles, Newton Warp Raytrace, Madrona both in speed, throughput, and image quality
+- Validation with real-world sensors and scenes.
+
+## Installation
+
+The Python package is on PyPI as `ernie-renderer` (Python 3.10 or later, with a Vulkan 1.3 driver). It bundles everything else, the viewer and the native `ernie` program included:
+
+```sh
+pip install ernie-renderer
+```
+
+Each GitHub release also has an `ernie` package for Ubuntu 22.04+, Debian 12+ and RHEL 9+ (and a tarball for other distributions), with the library, the viewer, and the headers and CMake package for building against it in C++. Download it from the [latest release](https://github.com/alexmaietta/ernie/releases/latest) and install it with a Vulkan driver: Mesa's below, which includes the lavapipe software driver for machines without a GPU, or your GPU vendor's.
+
+```sh
+# Debian, Ubuntu
+sudo apt install mesa-vulkan-drivers
+sudo apt install ./ernie_*.deb
+
+# RHEL, Rocky, Fedora
+sudo dnf install mesa-vulkan-drivers
+sudo dnf install ./ernie-*.rpm
+```
+
+### Docker
+
+The `ernie` program is also published as a Docker image.
+
+```sh
+docker run --rm --gpus all -v "$PWD:/out" ghcr.io/alexmaietta/ernie --demo demo_atmosphere_earth --viewer null --output /out/earth.png
+```
+
+### Build from source
+
+Ernie needs CMake 3.24+, a C++20 compiler, Python 3.10+ with its development headers (or `-DERNIE_BUILD_PYTHON=OFF`) and a Vulkan 1.3 driver. Small dependencies are vendored; Slang and OpenEXR are fetched on first configure (see [third_party/README.md](third_party/README.md)).
+
+```sh
+cmake -S . -B build -DERNIE_BUILD_TESTS=ON
+cmake --build build
+ctest --test-dir build -j4              # C++, GPU and Python tests
+build/bin/ernie                         # the viewer
+cmake --install build --prefix ~/.local # libernie, headers and the CMake package
+```
+
+To build the Python wheel instead, run `uv build --wheel --out-dir dist .` and `uv pip install dist/ernie_renderer-*.whl`; for the Linux packages, `cmake --preset package-deb` (or `package-rpm`), `cmake --build --preset package-deb` and `cpack --preset package-deb`. See [CONTRIBUTING.md](CONTRIBUTING.md) for the build options, testing without a GPU on lavapipe, and benchmarks.
+
+## Quick Start
+
+Run `ernie` to open the Ernie Viewer. Its Demos panel runs any of the built-in demos, each written in both C++ and Python, covering cameras and sensors, lighting, atmospheres, terrain, lasers, batched rendering and the viewer; the two versions of a demo render the same image.
+
+```sh
+ernie                               # the viewer, with the Demos panel
+ernie --list                        # every demo's name
+ernie --demo demo_atmosphere_earth  # run one demo
+ernie --help                        # every option
+```
+
+`python -m ernie` opens the same viewer and takes the same options, and `python -m ernie.demos` runs the Python version of a demo:
+
+```sh
+python -m ernie.demos --list
+python -m ernie.demos demo_atmosphere_earth
+```
+
+Every demo takes common options, such as `--viewer null` to render without a window and `--output frame.png` to save the last frame; `--help` lists them.
+
+## Your First Render
+
+### Python
+
+```python
+from PIL import Image
+
+import ernie
+from ernie import tokens
+
+scene = ernie.Scene()
+scene.define("/World/Ground", ernie.GroundPlane)
+scene.define("/World/Rock", ernie.Sphere, translate=(0, 0, 1))  # 1 m up
+scene.define("/World/Sun", ernie.DistantLight).set(
+    tokens.TRANSFORM, ernie.distant_light_transform((0.4, -0.6, 0.7))
+)
+scene.define("/World/Camera", ernie.Camera).set(
+    tokens.TRANSFORM, ernie.look_at_transform((0, -8, 3), (0, 0, 1))
+)
+scene.define(
+    "/Render/Settings", ernie.RenderSettings, camera="/World/Camera", resolution=(640, 480)
+)
+
+renderer = ernie.Renderer()
+image = renderer.render(scene)  # a (480, 640, 4) uint8 NumPy array
+Image.fromarray(image).save("ernie.png")
+```
+
+### C++
+
+With the `ernie` package or your own build installed, find it with CMake:
+
+```cmake
+find_package(Ernie REQUIRED)
+target_link_libraries(my_app PRIVATE Ernie::ernie)
+```
+
+```cpp
+#include <ernie/scene/schemas.h>
+#include <ernie/scene/tokens.h>
+#include <ernie/scene/xform.h>
+#include <ernie/render/renderer.h>
+
+int main() {
+    using namespace ernie;
+    Scene scene;
+    GroundPlane::Define(scene, "/World/Ground");
+    Sphere::Define(scene, "/World/Rock");
+    SetXform(scene, "/World/Rock", {.translate = glm::dvec3(0.0, 0.0, 1.0)});  // 1 m up
+    DistantLight::Define(scene, "/World/Sun");
+    scene.Set("/World/Sun", tokens::kTransform, DistantLightTransform({0.4, -0.6, 0.7}));
+    Camera::Define(scene, "/World/Camera");
+    scene.Set("/World/Camera", tokens::kTransform,
+              LookAtTransform({0.0, -8.0, 3.0}, {0.0, 0.0, 1.0}, {0.0, 0.0, 1.0}));
+    RenderSettings::Define(scene, "/Render/Settings")
+        .SetCamera("/World/Camera")
+        .SetResolution({640, 480});
+
+    Renderer renderer;
+    Tensor image = renderer.Render(scene);  // 480 x 640 x 4 bytes of LdrColor on the CPU
+}
+```
+
+## Citation
+
+If you use Ernie in your research, please cite it. GitHub's "Cite this repository" button gives the same citation from [CITATION.cff](CITATION.cff).
+
+```bibtex
+@software{maietta2026ernie,
+  author  = {Maietta, Alex},
+  title   = {Ernie: Efficient Renderer for Natural and Interplanetary Environments},
+  year    = {2026},
+  version = {0.1.0},
+  url     = {https://github.com/alexmaietta/ernie},
+  license = {BSD-3-Clause}
+}
+```
+
+## License
+
+Ernie is licensed under the [BSD 3-Clause License](LICENSE). The third-party libraries it bundles keep their own licenses, listed in [third_party/README.md](third_party/README.md).

ernie_renderer-0.2.0.dev76/README.md

@@ -0,0 +1,215 @@
+> 🚧 **This project is in active beta development.** This means the API is unstable, features may be added or removed, and breaking changes are likely to occur frequently and without notice as the design is refined.
+
+[![CI](https://github.com/alexmaietta/ernie/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/alexmaietta/ernie/actions/workflows/ci.yml)
+[![Coverage](https://img.shields.io/endpoint?url=https%3A%2F%2Falexmaietta.github.io%2Fernie%2Fcoverage%2Fbadge.json)](https://alexmaietta.github.io/ernie/coverage/)
+[![Release](https://img.shields.io/github/v/release/alexmaietta/ernie?include_prereleases&sort=semver&color=orange)](https://github.com/alexmaietta/ernie/releases)
+[![PyPI](https://img.shields.io/pypi/v/ernie-renderer?color=3775A9&logo=pypi&logoColor=white)](https://pypi.org/project/ernie-renderer/)
+[![Docs](https://img.shields.io/badge/docs-latest-8A2BE2)](https://alexmaietta.github.io/ernie/)
+[![License](https://img.shields.io/badge/license-BSD--3--Clause-2E8B57)](LICENSE)
+
+# Efficient Renderer for Natural and Interplanetary Environments (Ernie)
+
+![]()
+
+Ernie is a physically accurate, real-time, spectral renderer for interplanetary environments.
+
+It is a Vulkan ray tracer for Linux, Windows and macOS (through MoltenVK), with C++ and Python APIs and a Hydra-like scene API. Ernie is designed around physical quantities, efficient batched rendering, and interoperability.
+
+Ernie is built to be extensible, customizable, and to work alongside other tools. You can add your own BRDFs, sensor filters and light patterns. Rendered outputs and scene attributes (transforms, mesh vertices, light parameters and more) are shared zero copy with any DLPack tensor (PyTorch, JAX, Warp, NumPy), which makes Ernie a good fit for real-time physics simulation and reinforcement learning. Support for OpenUSD and glTF scenes, and for MDL and MaterialX materials, is planned.
+
+Its key features are aimed at planetary robotics and sensing:
+
+- **Spectral light**
+    - Light carried in bands (16 across 380-780 nm by default, up to 64 into the infrared) from the source, through materials and media, to the sensor
+    - Sun, sky, lamps, domes and lasers in physical units, with measured spectra such as the TSIS-1 sun
+    - Distant lights as limb-darkened discs whose angular size sets every penumbra
+- **Planets and space**
+    - Terrain and whole planets with continuous level of detail from orbit to the ground, their heights and maps streamed from rasters larger than GPU memory
+    - Adaptive spheres and ellipsoids, exact from a pebble to a star, in double precision with a floating origin and reverse-Z depth
+    - Earth and Mars atmospheres from physical models, with refraction, seen from the ground or from orbit
+    - Eclipses cast by real geometry, and star fields from your own catalogues
+- **Materials**
+    - Planetary photometry with Hapke, Lommel-Seeliger and lunar-Lambert, with parameters from texture maps
+    - OpenPBR Surface and UsdPreviewSurface, spectral throughout
+    - Your own BRDFs written in Slang
+- **Cameras and sensors**
+    - Perspective, fisheye, orthographic and line-scan pushbroom cameras, with CAHVORE and USGS CSM instrument models
+    - The EMVA 1288 sensor model: quantum efficiency, shot and read noise, dark current, PRNU, DSNU, full well and ADC
+    - Filter chains for optics and detectors (diffraction, lens flare, blooming, smear, TDI, Bayer, companding), with your own in Slang
+    - Polarization cameras
+- **Thermal infrared**
+    - Planck emission from surfaces and volumes, with emissivity from Kirchhoff's law or measured spectra
+    - Temperatures from your own solver, textures, or models run per pixel: spacecraft energy balance and diurnal tables for airless bodies
+    - Microbolometer cameras with NETD, fixed pattern noise and false-colour palettes
+- **Volumes**
+    - Smoke, dust, exhaust plumes and clouds from VDB files or GPU arrays, ray marched spectrally and casting shadows
+    - Procedural cloud layers, with Mie droplets for silver linings, fogbows and glories
+- **Lasers and structured light**
+    - Gaussian beams and diffractive patterns (lines, grids, dot fields or your own), pulses, speckle, and beams seen in dust and air
+- **Simulation and learning**
+    - Thousands of worlds and cameras rendered in one batched step for RL and Monte Carlo workloads
+    - Inputs and outputs shared without copies with PyTorch, JAX, Warp and NumPy, through CUDA and HIP
+    - Columns and incremental sync: thousands of prims' poses written in one call, and an edit redraws only what it reaches
+- **Tools and integrations**
+    - A viewer with your own panels and debug drawing, and C++ and Python APIs on Linux, Windows and macOS
+    - OpenUSD import, renderer backends for Newton Viewer, IsaacLab and Chrono::Sensor, and TerrainGen built on the viewer
+
+For a more detailed overview of the features, see our [documentation](https://alexmaietta.github.io/ernie/).
+
+Future work:
+
+- A fully USD- and glTF-compliant renderer, loading OpenUSD, glTF, OBJ, STL and 3D Tiles, with the glTF material system, UsdPreviewSurface shaders and MDL and MaterialX support
+- Differentiable rendering
+- Reflections and global illumination
+- OpenXR integrations
+- WebGPU backend
+- Gaussian splat and particle fields
+- Lidar and radar sensors
+- A real-time ray-tracing renderer alongside the rasterizer
+- Integrations into Newton Viewer, Chrono Sensor, and IsaacLab
+- Benchmark against RTX, Cycles, Newton Warp Raytrace, Madrona both in speed, throughput, and image quality
+- Validation with real-world sensors and scenes.
+
+## Installation
+
+The Python package is on PyPI as `ernie-renderer` (Python 3.10 or later, with a Vulkan 1.3 driver). It bundles everything else, the viewer and the native `ernie` program included:
+
+```sh
+pip install ernie-renderer
+```
+
+Each GitHub release also has an `ernie` package for Ubuntu 22.04+, Debian 12+ and RHEL 9+ (and a tarball for other distributions), with the library, the viewer, and the headers and CMake package for building against it in C++. Download it from the [latest release](https://github.com/alexmaietta/ernie/releases/latest) and install it with a Vulkan driver: Mesa's below, which includes the lavapipe software driver for machines without a GPU, or your GPU vendor's.
+
+```sh
+# Debian, Ubuntu
+sudo apt install mesa-vulkan-drivers
+sudo apt install ./ernie_*.deb
+
+# RHEL, Rocky, Fedora
+sudo dnf install mesa-vulkan-drivers
+sudo dnf install ./ernie-*.rpm
+```
+
+### Docker
+
+The `ernie` program is also published as a Docker image.
+
+```sh
+docker run --rm --gpus all -v "$PWD:/out" ghcr.io/alexmaietta/ernie --demo demo_atmosphere_earth --viewer null --output /out/earth.png
+```
+
+### Build from source
+
+Ernie needs CMake 3.24+, a C++20 compiler, Python 3.10+ with its development headers (or `-DERNIE_BUILD_PYTHON=OFF`) and a Vulkan 1.3 driver. Small dependencies are vendored; Slang and OpenEXR are fetched on first configure (see [third_party/README.md](third_party/README.md)).
+
+```sh
+cmake -S . -B build -DERNIE_BUILD_TESTS=ON
+cmake --build build
+ctest --test-dir build -j4              # C++, GPU and Python tests
+build/bin/ernie                         # the viewer
+cmake --install build --prefix ~/.local # libernie, headers and the CMake package
+```
+
+To build the Python wheel instead, run `uv build --wheel --out-dir dist .` and `uv pip install dist/ernie_renderer-*.whl`; for the Linux packages, `cmake --preset package-deb` (or `package-rpm`), `cmake --build --preset package-deb` and `cpack --preset package-deb`. See [CONTRIBUTING.md](CONTRIBUTING.md) for the build options, testing without a GPU on lavapipe, and benchmarks.
+
+## Quick Start
+
+Run `ernie` to open the Ernie Viewer. Its Demos panel runs any of the built-in demos, each written in both C++ and Python, covering cameras and sensors, lighting, atmospheres, terrain, lasers, batched rendering and the viewer; the two versions of a demo render the same image.
+
+```sh
+ernie                               # the viewer, with the Demos panel
+ernie --list                        # every demo's name
+ernie --demo demo_atmosphere_earth  # run one demo
+ernie --help                        # every option
+```
+
+`python -m ernie` opens the same viewer and takes the same options, and `python -m ernie.demos` runs the Python version of a demo:
+
+```sh
+python -m ernie.demos --list
+python -m ernie.demos demo_atmosphere_earth
+```
+
+Every demo takes common options, such as `--viewer null` to render without a window and `--output frame.png` to save the last frame; `--help` lists them.
+
+## Your First Render
+
+### Python
+
+```python
+from PIL import Image
+
+import ernie
+from ernie import tokens
+
+scene = ernie.Scene()
+scene.define("/World/Ground", ernie.GroundPlane)
+scene.define("/World/Rock", ernie.Sphere, translate=(0, 0, 1))  # 1 m up
+scene.define("/World/Sun", ernie.DistantLight).set(
+    tokens.TRANSFORM, ernie.distant_light_transform((0.4, -0.6, 0.7))
+)
+scene.define("/World/Camera", ernie.Camera).set(
+    tokens.TRANSFORM, ernie.look_at_transform((0, -8, 3), (0, 0, 1))
+)
+scene.define(
+    "/Render/Settings", ernie.RenderSettings, camera="/World/Camera", resolution=(640, 480)
+)
+
+renderer = ernie.Renderer()
+image = renderer.render(scene)  # a (480, 640, 4) uint8 NumPy array
+Image.fromarray(image).save("ernie.png")
+```
+
+### C++
+
+With the `ernie` package or your own build installed, find it with CMake:
+
+```cmake
+find_package(Ernie REQUIRED)
+target_link_libraries(my_app PRIVATE Ernie::ernie)
+```
+
+```cpp
+#include <ernie/scene/schemas.h>
+#include <ernie/scene/tokens.h>
+#include <ernie/scene/xform.h>
+#include <ernie/render/renderer.h>
+
+int main() {
+    using namespace ernie;
+    Scene scene;
+    GroundPlane::Define(scene, "/World/Ground");
+    Sphere::Define(scene, "/World/Rock");
+    SetXform(scene, "/World/Rock", {.translate = glm::dvec3(0.0, 0.0, 1.0)});  // 1 m up
+    DistantLight::Define(scene, "/World/Sun");
+    scene.Set("/World/Sun", tokens::kTransform, DistantLightTransform({0.4, -0.6, 0.7}));
+    Camera::Define(scene, "/World/Camera");
+    scene.Set("/World/Camera", tokens::kTransform,
+              LookAtTransform({0.0, -8.0, 3.0}, {0.0, 0.0, 1.0}, {0.0, 0.0, 1.0}));
+    RenderSettings::Define(scene, "/Render/Settings")
+        .SetCamera("/World/Camera")
+        .SetResolution({640, 480});
+
+    Renderer renderer;
+    Tensor image = renderer.Render(scene);  // 480 x 640 x 4 bytes of LdrColor on the CPU
+}
+```
+
+## Citation
+
+If you use Ernie in your research, please cite it. GitHub's "Cite this repository" button gives the same citation from [CITATION.cff](CITATION.cff).
+
+```bibtex
+@software{maietta2026ernie,
+  author  = {Maietta, Alex},
+  title   = {Ernie: Efficient Renderer for Natural and Interplanetary Environments},
+  year    = {2026},
+  version = {0.1.0},
+  url     = {https://github.com/alexmaietta/ernie},
+  license = {BSD-3-Clause}
+}
+```
+
+## License
+
+Ernie is licensed under the [BSD 3-Clause License](LICENSE). The third-party libraries it bundles keep their own licenses, listed in [third_party/README.md](third_party/README.md).

ernie_renderer-0.2.0.dev76/benchmarks/CMakeLists.txt

@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: BSD-3-Clause
+add_executable(ernie_benchmarks main.cpp device/pose_step.cpp scene/extents.cpp scene/storage.cpp)
+target_link_libraries(
+    ernie_benchmarks
+    PRIVATE ernie_static ernie_volk ernie_vma ernie_build_options
+)

ernie_renderer-0.2.0.dev76/benchmarks/device/pose_step.cpp

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file pose_step.cpp
+/// @brief A steady-state step of 16,384 instances on device columns: poses written in place,
+/// then turned into instance transforms, with no bulk bytes through the host.
+#include "tests/device/pose_step.h"
+#include "benchmarks/bench.h"
+
+#include <cstdio>
+#include <memory>
+
+namespace ernie::bench {
+namespace {
+
+const bool kPoseStep = Register("device.pose_step.16k_instances", [] {
+    std::unique_ptr<DeviceContext> context;
+    try {
+        context = std::make_unique<DeviceContext>();
+    } catch (const DeviceError& error) {
+        std::printf("skipped: %s\n", error.what());
+        return Timing{0.0, 1.0};
+    }
+    const ShaderCompiler compiler;
+    test::PoseStep poses(*context, compiler, 16'384);
+    std::uint32_t step = 0;
+    const auto run = [&] { poses.Step(++step).Wait(); };
+    run();
+    const Transfers before = context->Transfers();
+    const double ms = Fastest([] {}, run, 20);
+    if (context->Transfers() != before) {
+        std::printf("device.pose_step.16k_instances moved bytes through the host\n");
+    }
+    return Timing{ms, 1.0};
+});
+
+}  // namespace
+}  // namespace ernie::bench