Registration is now open for the 2025 Cesium Developer Conference! Save your spot.

Cesium for Omniverse v0.24.0

Cesium for Unity Samples v1.15.5

CesiumJS 1.128

CesiumJS

This summer’s inaugural Cesium Developer Conference, June 23-25 in Philadelphia, is an opportunity for developers to network and learn about the latest and greatest open geospatial tools, standards, and data. For attendees looking for a hands-on experience to learn Cesium, we are excited to offer the "Cesium Deep Dive," a pre-conference training full-day workshop on Monday, June 23.

Register and select the Cesium Deep Dive training

Northern California, USA, using Google Photorealistic 3D Tiles in CesiumJS.

If you are a burgeoning geospatial developer, this workshop is for you.

Bring your own laptop so you’re prepared to build, ask questions, and learn new skills to take your 3D geospatial projects to the next level.

Training includes intros to CesiumJS and Cesium ion, then explores deeper discussions on deploying Cesium Native and using 3D creation engine plugins. 

Engineers will present ready-to-try exercises and will be present to help you explore features of Cesium and 3D Tiles. There will also be opportunities for you to meet 1:1 with engineers if you need help with a specific question.

We’re excited to have two special guests presenting and mentoring attendees throughout the day:

Tim Woodard, Principal Solutions Architect at NVIDIA, will present an update on NVIDIA Omniverse and how using it can benefit open geospatial developers.

Stephen Phillips, Solution Architect at Epic Games, will give an overview of how Unreal Engine can be used in AEC and geospatial applications.

Using Cesium runtime plugins for geospatial context

Unreal Engine for geospatial and AEC applications

NVIDIA Omniverse architecture and applications

Prior to the workshop, the Cesium team will send out information to registered training attendees with instructions for downloads and device configuration so that you are ready when you arrive.

The Grand Canyon, USA, visualized with Cesium for Omniverse.

Will I become a Cesium Certified Developer?

We’ve been getting this question a lot: Will a workshop attendee automatically become a Cesium Certified Developer?

No. Certification is based on one's ability to deploy the skills covered throughout this workshop in their own work. You will learn many of the skills needed for certification over the course of the day, and then it will be up to you to put these skills into practice and submit your project. Our Certification team will be on site throughout the full conference to discuss certification. 

Learn more about becoming a Cesium Certified Developer here.

Sign up for the training through the regular conference registration process. There is an additional fee ($100) to attend the workshop because space is limited. Lunch and refreshments are provided.

Slots are filling up. We look forward to learning with you.

Register for the conference and add the workshop

Deep Dive Workshop at the Cesium Developer Conference

In March, we attended NVIDIA GTC 2025, presented at The Khronos Group’s “3D on the Web” during GDC 2025, and shared that the Cesium Design Tiler now preserves metadata from Industry Foundation Classes (IFC) when tiling into 3D Tiles. 

We’re also hard at work on finalizing the agenda for the 2025 Cesium Developer Conference. Register to join us in Philadelphia in June.  

Color ramp shading based on an IFC length property in Cesium for Unreal. Data source: BSI (2020) "Medical-Dental Test Files," buildingSMART International—accessible via GitHub.

We made improvements across Cesium this month. To get notifications about our monthly releases, you can subscribe to the Cesium release roundup thread on our community forum.

CesiumJS 1.128 is now available. Highlights of the release include:

Added support for loading iTwin data using share keys as an alternative to user-based OAuth. When using a share key, set ITwinPlatform.defaultShareKey. #12530 

Added Frozen.EMPTY_OBJECT and Frozen.EMPTY_ARRAY for use as default parameter values that avoid unnecessary memory allocations. #12507 

Fixed entity tracking for delayed datasource bounding spheres. #12465 

Camera.getPickRay now correctly returns a ray with origin in world coordinates in orthographic mode. #12500 

Fixed camera zooming in 3D orthographic mode when pixelRatio is not 1. #12487 

Fixed shape bounds and transforms for cylinder-shaped voxels. #12522 

Fixed an issue where clamped entities' height updates could stall when using high-resolution terrain due to a growing queue of tiles in updateHeights in QuadtreePrimitive. #12476 

Cesium for Unreal v2.15.0 is now available. Highlights of this release include:

Actors spawned through the Cesium editor panel, such as tilesets and cartographic polygons, will now be parented to the first selected georeference—if any—instead of always being parented to the first georeference in the scene. 

WorldHeight Runtime Virtual Texture output is now set to the Z component of the world position. 

Fixed a bug where a glTF material with alphaMode=BLEND would be rendered as opaque if its baseColorFactor was not set. 

Fixed a crash that could occur when rapidly refreshing a tileset. 

Fixed a crash when tilesets with point clouds were used in combination with Hardware Ray Tracing. 

Worked around an apparent Metal problem that prevented polygon clipping from working correctly on macOS. 

Fixed normals being incorrectly written to Runtime Virtual Texture output in tangent space instead of in world space. 

When a glTF contains external resources like textures and buffers, requests for these external resources now include query parameters that were used to request the original glTF. This is important when using access tokens and similar. 

Fixed bugs that could prevent valid metadata in Instanced 3D Model (i3dm) files from being parsed correctly. 

Fixed a small memory leak while reading glTF files. 

Check the Cesium for Unreal release and the Cesium for Unreal Samples release for the full list of updates.

Download the Cesium for Unreal plugin from Epic Marketplace

Cesium for Unity v1.15.5 is now available. Highlights of this release include:

Fixed a bug that could cause a crash when reloading a scene or tileset repeatedly. 

Check the Cesium for Unity changelog for the full list of updates, and follow our Cesium for Unity tutorials to get started. 

The Cesium Design Tiler now preserves metadata from Industry Foundation Classes (IFC) when tiling into 3D Tiles. Metadata support includes IFC attributes, property sets, and properties. Read more. 

As part of our ongoing effort to improve performance, we are adding a "Region" field to Cesium ion. New users will be asked to set their region when setting up their account. For existing accounts, we will automatically set the region based on the locations from which data requests have been made in the past year. 

glTF node names are now preserved as metadata. 

IFC metadata attributes type detection added, no longer limited to just strings. 

fix for a regression with terrain water masks 

Check the changelogs for the full list of updates for Cesium ion SaaS and Cesium ion Self-Hosted.

Blyncsy uses CesiumJS to show potential users how the company’s roadway data can be used in a visualization engine. 

The Weather Company improves military training and planning by pairing its detailed weather data with geospatial context in apps using Cesium for Unreal and CesiumJS.   

Defense and other government agencies rely on current weather information, forecasts, and historical data for situational awareness and effective decision-making. The Weather Company (TWC) improves military training and planning by pairing its detailed weather data with geospatial context in apps using Cesium for Unreal and CesiumJS.  

WeatherverseTM provides accessible, accurate, and actionable government weather forecast data and visualizations to improve outcomes, reduce costs, and help protect lives. Courtesy The Weather Company.

The Weather Company: Weatherverse

TWC was founded in the 1980s, addressing needs across various industries, and began serving government agencies in 2022. Sudden changes in weather conditions affect personnel and equipment, even with otherwise meticulous planning.  

Weatherverse Sim prepares warfighters with accurate 3D visualizations of environments and conditions—such as strong wind, more rain, or less cloud coverage—simulating weather they might face in the field. With recording and playback, trainees can experience and memorize scenarios for anywhere in the world, and trainers can adjust future sessions. Google Photorealistic 3D Tiles are streamed with data from TWC’s SUN Spatial Data Services and other sources for a comprehensive picture. Weatherverse Sim has used Cesium for Unreal since 2023 to bring realistic weather elements and geospecific terrain to these simulations, increasing operational effectiveness. 

Weatherverse Sim uses Cesium for Unreal to combine weather elements and terrain. Courtesy The Weather Company.

Weatherverse Planner monitors the forecast for locations important to planning teams and their missions, so they know what impacts weather will have on aviation, communications, infantry, and more. Users set thresholds and alerts for conditions like lightning, wind, or precipitation, for example, to make better informed decisions. Weatherverse Planner can be used as a stand-alone solution or integrated as a widget within any CesiumJS-based app for reliable performance on the web, streaming Bing Maps Aerial imagery for the view from space. Fusing weather data and geospatial context instead of managing multiple separate systems concurrently saves time and lives. Weatherverse Planner has used CesiumJS since 2024. 

Weather risk, based on user-defined parameters, in Weatherverse Planner. Courtesy The Weather Company.

Precipitation in Weatherverse Planner. Courtesy The Weather Company.

Weather conditions in Singleton, Australia, in Weatherverse Planner. Courtesy The Weather Company.

SimCentric’s CesiumJS-based SAF-Foresight app for planning and safety for live fire exercises will deploy Weatherverse Planner as a plugin for Exercise Talisman Sabre 2025. Exercise Talisman Sabre is the largest combined military training activity between Australia and the United States, with other partner nations joining, and this year it will incorporate real-time weather information to improve readiness. 

The Weather Company has built on top of CesiumJS as a plugin to further support and integrate Weatherverse Planner. The TWC-Cesium Plugin includes the protocols for acquiring, storing, querying, and filtering weather data from its SUN weather and spatial data services and integrates with existing Cesium-based apps. It is in an experimental phase. 

“Cesium provides a deep and rich set of capabilities, especially with regards to 3D orientation and geospatial data visualization. The framework is also well documented, approachable, and performant,” said J.R. Cottingham, senior director for The Weather Company’s Weatherverse. 

Weatherverse Planner deployed as a widget in CesiumJS-powered SAF-Foresight. Courtesy The Weather Company and SimCentric.

TWC is working to improve Weatherverse Planner with additional weather visualizations, such as wind streams. 

Built on open standards to support interoperability and with commitment to rapid innovation, Cesium powers mission-critical applications to better understand the operational environment. Read more federal and defense-related stories. 

The Weather Company Brings Forecasts to Military Planning with Cesium 

Keeping roads well maintained and safe for travel requires up-to-date information about roadway conditions, including potholes, missing signage, guardrail damage, and other potential safety hazards.  

Blyncsy, founded in 2014 and acquired by Bentley in 2023, uses AI, machine vision, and cloud computing to help US state and local transportation agencies spot issues more efficiently than with resource-heavy manual methods. CesiumJS plays a critical role in helping Blyncsy show potential users how the company’s data can be used in a visualization engine. 

Striping retroreflectivity across the US. Courtesy Blyncsy. 

Blyncsy gets road pictures by crowdsourcing images from over 1,200,000 vehicles, including privately owned commercial and fleet vehicles and delivery trucks. The company anonymizes the data and securely stores it in the cloud, where it can be studied and analyzed by machine learning systems, machine vision, and AI. The analyzed data is then delivered to users through Open Geospatial Consortium (OGC) APIs, ensuring seamless integration with a variety of platforms, including Cesium and other transportation management systems, for georeferencing, visualization, and analysis.  

“Selling data is abstract. Since the beginning, long before we were acquired, CesiumJS has provided a flexible, easy to use, and high-performing way to show the value of our solution to potential customers,” Pat Brown, principal software engineer at Blyncsy, explained. “Cesium’s open-source approach was also a big draw for us—it gave us the freedom to innovate without being constrained by licensing fees or proprietary limitations.” 

Brown and his colleagues use CesiumJS not only to attract new business but also to save valuable engineering resources: “With CesiumJS we can focus our team’s time on building our platform instead of the front-end engineering that would be needed to eloquently visualize the data.” 

US interstate highway system roadway safety and maintenance conditions. Courtesy Blyncsy.

In 2023, Blyncsy began publishing a series of their AI-powered detection maps to provide state and local agencies with free access to select datasets. Built on CesiumJS with TerriaMap, that series includes a comprehensive public map of all interstate highways in the continental US, showing key roadway assets such as guardrails, speed limit signs, and work zones to support roadway safety and maintenance conditions.  

Laura Chace, president and CEO of Intelligent Transportation Society of America (ITS America), lauded the release of Blyncsy’s publicly available maps. ITS America was established by Congress in 1991 to serve as an advisor to the US Department of Transportation and advocates for a smarter, greener future transformed by transportation technology and innovation. 

“The application of advanced technologies like AI, combined with new sources of data, are transforming the transportation sector, giving us better information as we make investments in safety and mobility,” Chace said in a Bentley blog. “We applaud companies like Blyncsy for deploying these forward-thinking technologies and making this digital infrastructure data available to the public in an accessible format.”  

Blyncsy uses AI, machine vision, and cloud computing to help US state and local transportation agencies spot roadway issues. Courtesy Blyncsy.

Learn to easily and eloquently visualize and analyze data from multiple sources with CesiumJS.  

Join us at the 2025 Cesium Developer Conference to connect with Blyncsy and others with technically oriented, community-driven tracks. 

Blyncsy Shows Transportation Agencies the Future of Roadway Maintenance with CesiumJS

In February, we explored enhancements to our lighting system in CesiumJS, attended Geo Week and the LA Geospatial Summit, and opened registration for the 2025 Cesium Developer Conference. Join us in June for technically oriented, community-driven tracks at our inaugural event. 

CesiumJS 1.127 is now available. Highlights of the release include:

Updated Cesium3DTilesVoxelProvider to load glTF tiles using the new EXT_primitive_voxels extension to more closely align with the rest of the 3D Tiles ecosystem. Tilesets using the previous custom JSON format are no longer supported. #12432 

Updated the requestData method of the VoxelProvider interface to return a Promise to a VoxelContent. Custom providers should now use the VoxelContent.fromMetadataArray method to construct the returned data object. 

TextureAtlas has been refactored and internal APIs have been updated. 

Implemented texturesByteLength, visited, and numberOfTilesWithContentReady in VoxelPrimitive.statistics. 

Procedurally generated box voxels in CesiumJS.

Cesium for Unreal v2.14.0 is now available. Highlights of this release include:

Added support for drawing 3D Tilesets to Runtime Virtual Textures. 

Added support for "enum" properties in EXT_structural_metadata. 

"External Tilesets" are now unloaded when they are no longer used. This will significantly reduce the growth of memory usage over time when using Google Photorealistic 3D Tiles and similar tilesets. 

Left: building roofs overlaid onto the Cesium OSM Buildings tileset using a Bing Maps Raster Overlay. Right: building roofs overlaid onto the Cesium OSM Buildings tileset using the new Runtime Virtual Texture support in Cesium for Unreal v2.14.0.

Cesium for Unity v1.15.4 is now available. Highlights of this release include:

Comparison of memory usage from loaded tiles over time in Cesium for Unity v1.15.3 as compared to the new release, Cesium for Unity v1.15.4.

Assets now support multi-selection for deleting multiple assets at once. 

Cesium Stories annotations provide an option to show the name of the annotation in the 3D view. 

Added the ability to import source data from Azure and export tiled asset data to Azure. This must be enabled under the features section of values.yaml. 

Cesium Stories now include annotation features for points, polygons, and polylines. 

Assets page now supports multi-selection for deleting multiple assets at once. 

A new installer script is available to assist with single node installations using Microk8s. 

New tabs are now available on the Administration panel when running with SAML mode. These tabs allow administrators to view the users in the system, upload an asset to a user's account, delete assets from a user's account and re-run failed jobs through the UI. 

The Administration panel now also provides access to the logs of a failed job through the Cesium ion UI. 

Tiler updates will be available this month. Highlights will include: 

- Major announcements 
    - The design tiler will be included in the official 3D Tiling Pipeline release. 
    - The `tilers` executable will be split into separate executables: `reality-tiler` and `design-tiler`. 

- Design Tiler 
    - Add support for line and point primitives. 
    - Add support for IFC metadata. 
    - Meshopt compression applied to instance attributes. 
    - Input models that don't contain metadata pickable. 
    - Fix reading .obj models. 
    - Fix bug where Draco compression would sometimes generate extra vertices. 
    - Fix bounding volume alignment when geometry is far away from the origin. 
    - Fix texture coordinate scaling when input model uses `KHR_texture_transform`. 
    - Improve coordinate conversion for instanced geometry. 
    - Variety of metadata related improvements. 

- Clip Tileset 
    - Fix a bug that could cause `clip-tileset` to excessively upsample while clipping tilesets with raster overlays. This could cause the process to take an excessive amount of time, or to run out of memory and crash. 

- Reality Tiler 
    - Remove support for the `--sanitize-error-logs` CLI flag; paths in error logs are now always sanitized by default.
    - Add support for tiling models with vertex colors. 

Author’s note: Many thanks to my colleague Jeshurun Hembd for his significant contributions to these results. This is part 2 in a series about visual quality improvements in CesiumJS; read part 1 here.

With the growing adoption of Cesium for Unreal and Cesium for Unity, developers of native applications have raised the bar for visual quality in Cesium apps. Specialized game engine features—like dynamic sun and sky lighting components, light probes, and global illumination systems—now can be applied to geospatial use cases. The CesiumJS squad has been working to bring browser-based geospatial apps to a new level with dynamic approaches to lighting.

glTF model of a polished metal sphere reflecting the environment, rendered in CesiumJS using improved image-based lighting and an HDR-image environment map.

Good lighting is essential to make the most out of physically based rendering, or PBR, a rendering technique common to both models and 3D Tiles. Think of a polished metal sphere: It’d appear flat and dull without anything interesting to reflect. To complement recent rendering improvements we’ve made to the glTF material model in CesiumJS, we’ve shipped several enhancements to our lighting system over the last few releases, including:

Refinements to the image-based lighting pipeline

New York Buildings 3D Tileset, rendered in CesiumJS with ambient occlusion before these lighting updates (left, version 1.121) and after (right, version 1.125). The overall effect of the changes is more realistic lighting and more easily understood model form.

There are many strategies for lighting, but one tried-and-true method that’s been a part of CesiumJS for several years is image-based lighting, or IBL. Lighting for glTF PBR models and 3D Tiles combines a single directional light source (i.e., the sun) and IBL to simulate a variety of dynamic lighting conditions, such as the precise position of the sun based on time and geospatial location or scattering of light through the atmosphere.

glTF model, courtesy of noe-3d.at on Sketchfab, rendered in CesiumJS with directional lighting (left), image-based lighting (middle), and a combination of directional and image-based lighting (right). The combination results in the most apparent dimension and sense of place when viewing the model.

IBL is an appealing approach because it simulates a complex lighting environment—like hemispheric lighting from the sky, diffuse reflections from the ground, and any other light sources in a scene—with a single environment map. This map encodes a high dynamic range of lighting info in an omnidirectional texture, typically with an HDR image supplied by the user or a procedural texture generated at runtime.

While users have been able to import their own environment maps, this required offline use of external tooling like Khronos’s glTF IBL Sampler for preprocessing, making it less accessible to those without a knowledge of lighting pipelines. With our recent work, we can now use dynamic environment maps in CesiumJS that adapt to changes in time of day, atmospheric conditions, or model positioning. This means CesiumJS developers get the full benefits of IBL without any additional configuration.

Created on the GPU, dynamic environment maps can be updated in near-real time to reflect the current sun position and model location. When time of day, atmosphere settings, or model position change significantly, the environment map can be updated in the background over a few frames.

The Damaged Helmet glTF sample model rendered in CesiumJS with default procedural lighting in version 1.121 (left) and with dynamic environment maps in version 1.125 (right).

For apps with more specific lighting needs, there are options that can be adjusted, like the overall intensity of the light or the color reflected by the ground.

Our existing shaders for simulating the sky atmosphere based on time of day were flexible enough to be reused by adapting the viewing angle to the model origin. This means we can simulate lighting conditions at sunrise or sunset but also high up in the atmosphere for aircraft and satellites.

A glTF model of a polished metal sphere reflecting the environment at morning (left), noon (middle), and evening (right), as rendered with dynamic environment maps in CesiumJS.

From the environment map, we can determine both the diffuse lighting as well as the specular reflections on any model or 3D tileset. For low-roughness materials like polished metals, the environment map can be used to look up the reflection coming from any particular direction. Rougher objects scatter light and therefore reflect light in a more diffuse way. To represent this, we need to compute the average light contribution across a range of angles representative of the degree of scattering, an operation which involves sampling the environment map hundreds, if not thousands, of times. 

To optimize runtime performance, we precompute values on the GPU when a model is first loaded and then store them in data structures for lookup at runtime. The environment map is stored as a cubemap for quick lookup based on the direction of the reflected ray. Specular maps corresponding to various material roughness levels are stored in texture mipmaps that are used to sample the specular radiance. Finally, diffuse irradiance—that is the sum of all incoming light for any particular direction—is represented with third-order spherical harmonic coefficients, a total of nine sets of RBG values.

Data structures used for IBL precomputed on the GPU in CesiumJS: From the environment map, a cubemap is created with each increasing mipmap level representing the specular reflections of materials with increasing roughness. The most diffuse lighting is stored as an array of spherical harmonic coefficients.

Another key improvement to our existing IBL implementation came from revisiting our cubemapping. We switched our environment map pipeline from octahedral projection mapping, a method which worked great as a stopgap solution in WebGL 1, to native cubemaps supported by WebGL 2. The simplified approach removed redundant work on the GPU and made it significantly easier to fix bugs with LOD selection for specular maps.

Ambient occlusion, or AO, is key for understanding the form and depth of untextured models, such as those seen in OSM Buildings data or architectural design models. This technique darkens areas which would receive less ambient or indirect light, like corners or creases, creating a look of soft shadows. We use a post-processing screenspace-based approach, which is applied to a scene after it has been rendered.

glTF model, courtesy of noe-3d.at on Sketchfab, rendered in CesiumJS with combined lighting effects. Ambient occlusion alone highlights detail in the model’s form. When combined with image-based and directional lighting, we can approximate effects similar to a global lighting system without the need for baking lighting or other preprocessing.

As part of this effort, we fixed existing bugs with our screenspace implementation of AO and enabled a new scalable solution for use across a variety of scenarios.

Horizon-based ambient occlusion, or HBAO, uses sampling to determine the minimum angle at which the sky hemisphere is no longer visible from a position. When this is repeated across multiple directions, we have an estimate about the percentage of light in the scene that reaches each pixel. This technique helps visually communicate depth, form, and spatial proximity between objects in the scene, and it can be performed in screenspace for better runtime performance without the need to precompute lighting.

The key improvement made in our implementation was enhanced scalability. While typical AO use cases, like games or architectural visualization, are constrained to one scale, CesiumJS users can travel from outer space to underground in a single app. Previously, the AO parameters had to be configured manually based on trial and error to balance visual appearance with runtime performance. This was inconvenient for anything other than a specific view.

The limitation was the step size used to march along each sampling ray. Rather than using a fixed distance measured in meters, we implemented a normalized Gaussian distribution to scale the sample distance based on the distance from the camera, removing the need for any manual configuration. Occlusion now scales effectively from detailed interiors like pipes in a power plant to large cityscapes like buildings in New York City. Additionally, the falloff is now much smoother: As distance from the camera increases, the shadowed areas become wider, but less dark. In effect, it’s a much closer approximation of how light is occluded in reality.

glTF model, courtesy of noe-3d.at on Sketchfab, rendered in CesiumJS with ambient occlusion only. Scaling the sampling distance ensures views of the model at any scale, by default and without adjusting any settings.

We are committed to continuously pushing the boundaries of what can be achieved with browser-based 3D to provide users with better visualizations. The recent updates to IBL, dynamic environment maps, and ambient occlusion have been a few major steps in that journey.

glTF model showcasing diffuse lighting, courtesy of noe-3d.at on Sketchfab, rendered in CesiumJS before these lighting updates (left, version 1.121) and after (right, version 1.125). The overall effect of the changes is more realistic lighting and more apparent fine details.

Our efforts to enhance the visual quality of CesiumJS are always ongoing. We generated many ideas during this process—like an easier-to-use API for using HDR images and enhancements to how we render shadows—but your feedback is invaluable as we strive to further improve CesiumJS. Check out the Sandcastle example used throughout this blog, and please share your input on visual quality in this community thread.

Leveling Up Lighting in CesiumJS: IBL, Dynamic Environment Maps, and Ambient Occlusion

In January, we shared our code review guide, which we recently created and made available in our new public community repo, celebrated Danny’s Patriot Award from Pennsylvania Employer Support of the Guard and Reserve, and began calling for presentations for the 2025 Cesium Developer Conference. We look forward to seeing you in Philadelphia in June!

CesiumJS 1.126 is now available. Highlights of the release include:

Add ITwinData.loadGeospatialFeatures(iTwinId, collectionId) function to load data from the Geospatial Features API. #12449

Fixed error when resetting Cesium3DTileset.modelMatrix to its initial value. #12409

Fixed the parameter types of the ClippingPolygon.equals function and fixed cases where parameters to equals functions had erroneously not been marked as 'optional'. #12394

Fixed Draco decoding for vertex colors that are normalized UNSIGNED_BYTE or UNSIGNED_SHORT. #12417

Cesium for Unreal v2.13.1 is now available. Highlights of this release include:

Added CesiumUrlTemplateRasterOverlay, allowing a raster overlay to be added using tiles requested based on a specified URL template.

Added EstimateTimeZoneForLongitude method to ACesiumSunSky to set a reasonable TimeZone value at the given longitude.

The "Place Georeference Origin Here" button on ACesiumGeoreference will now adjust the time zone of the ACesiumSunSky instances that reference it, based on the new origin's longitude. This improves user experience when moving the origin to locations where it would be nighttime in the current time zone. A new EstimateTimeZoneForLongitude method on ACesiumSunSky can also be invoked manually from C++ or Blueprint.

Added RequestHeaders property to Cesium3DTileset, and the various Raster Overlay classes, allowing custom headers to be specified.

Worked around a limitation in Unreal's FMatrix -> FTransform conversion that prevented models with a small scale factor (e.g., where vertex positions are expressed in millimeters) from rendering because their scale was treated as 0.0.

Cesium for Unity v1.15.1 is now available. Highlights of this release include:

Exceptions in either C# or C++ code are now handled much more reliably.

Snowdon Sample Model from Autodesk Revit, streamed with 3D Tiles and visualized using Cesium for Unity. Featured in Level 08_CesiumArchitecturalDesign in Cesium for Unity Samples.

Cesium OSM Buildings and Cesium OSM Buildings for Cesium World Bathymetry datasets have been updated based on the OSM Timestamp of Jan 13 00:00 GMT 2025.

In addition to the Bing geocoder, Cesium ion now provides the Google geocoder for use in your applications. See this sandcastle for implementation.

In addition to the Bing geocoder, the Google geocoder is now available to applications using Cesium ion Self-Hosted when your Self-Hosted installation is connected to your Cesium ion SaaS account. See this sandcastle for implementation.

Cesium ion Self-Hosted v1.6.0, including the ability to upload data from Azure for tiling, will be released no later than early March 2025.

DroneDeploy enables stakeholders to examine the entire life cycle of a project with its drone software and viewer, which use 3D Tiles and Cesium ion Self-Hosted to make massive photogrammetry datasets manageable and accessible. With Cesium’s 3D Tiling Pipeline, DroneDeploy puts its engineering resources into its custom viewer rather than model processing, and users get photorealistic 3D models for decisions based on reality.

Capture high-resolution aerial data to align teams and keep AEC projects on track. Courtesy DroneDeploy.

DroneDeploy Map Engine

Code review is at the heart of what we do at Cesium. In this blog we discuss core principles around our review process and introduce our code review guide, which we recently created and made available in our new public community repo. At Cesium we maintain multiple open source repositories, most notably our runtime libraries for visualizing geospatial graphics on the web (CesiumJS) and via native engines (Cesium Native, Cesium for Unreal, Cesium for Unity, and Cesium for Omniverse), and since 2012 we have been making monthly releases of these libraries. CesiumJS alone has close to 250,000 lines of source code and 280,000 lines of test code. We also maintain Cesium ion SaaS and Cesium ion Self-Hosted, platforms for tiling, hosting, and streaming 3D geospatial data as 3D Tiles. To top it off, Cesium projects are built collaboratively between the community and the core team, with more than 300 external contributors committing source code to CesiumJS and dozens contributing commits to our native runtimes. 

Maintaining projects at this scale and in open source is not possible without strong engineering processes. Pull requests (PRs) and code reviews—more than most any other engineering process—are where rules are enforced and culture is built. Cesium has structured our guide to reinforce the core values of our engineering teams: Enhance code quality and consistency, streamline collaboration, facilitate knowledge sharing, and foster shared ownership. You may notice our guide doesn’t drill deep into language and framework-specific practices; we designed it as an overarching framework that can be augmented with specific tooling or style guides for our individual projects.

Here are the key principles at work in our guide. 

Tone: Seek great code and motivated people

We often say, "comments are about the code, not the people." We believe review comments are positive opportunities to discuss and improve. Our guide suggests using guiding questions and presenting evidence. Questions invite discussion and are a more gentle way to suggest changes. Every suggestion should be able to link to an authoritative source, like the project's coding guide, rather than relying on the reviewer's opinion. Empathy on the reviewer's part can go a long way toward keeping the contributor motivated in the review process.


Code review cannot happen without well organized projects, and we lean heavily on Git to organize our engineering projects. Git branches and branch protection rules enable collaboration and help us avoid forcing work in progress upon others before it's ready. Our guide advises keeping branches as focused as possible, avoiding mixing large-scale, cross-cutting changes with other changes. We suggest breaking complex changes into a sequence of smaller pull requests, each of which builds upon the previous. Lastly, we caution to avoid rebasing to preserve a usable version history.


Open timely and scoped PRs that create a historical record

We believe PRs should be small, targeted, and atomic. The PR author should create tasks lists covering and linking to all additional work required before merging. Team members should start code review and respond promptly (within 24 hours) to maintain momentum and investment from the author. Pull requests serve as a historical record of a change, so it is important to document the context of the pull request to help preserve it for future reference. The author should include why the change is being made and the test plan with steps and configuration needed to verify the change. Linking is an effective tool for documenting context: We create links to relevant issues (in the current repository or other projects), community forum posts or support threads, standards or API documentation, changelogs for dependencies, and best practices, such as blogs or guides.


Communicate status with automation, CI, and GitHub tooling

No matter the project, our guide advises using Github Actions workflows as part of continuous integration (CI) processes to enforce style guidelines through linting, code quality through unit tests and code scanning, and security through secrets checking and vulnerability scanning. The specific implementations of these checks depend entirely on the language and other features of the project, but automating them, as our guide recommends, streamlines and strengthens the code review process. The reviewer should ensure all checks pass and check artifacts for each stage to ensure that there are no “silent failures.”

Reviewers should maintain velocity by being concise and direct in their comments, avoiding the temptation to expand scope of the PR, and always trying to level up the team by providing impactful feedback that will then be sought after by other engineers. Our guide provides an overview of the critical areas a reviewer should look at before approving a PR, including design, execution, performance, complexity, third-party libraries, style, tests, and documentation of the code changes. 

Approving and merging a pull request means that the reviewer is accepting some responsibility for the code being merged. The author of the code is still largely accountable for any critical issues that immediately arise, but the reviewer shares some accountability as well. In practice, reviews differ by level of toughness depending on the change, which we thought was valuable to break as follows:

Rubber stamp: suitable for pull requests that only deal with documentation.

Skim the code and ensure all CI automation is passing: suitable for small pull requests.

Compile locally and run the code: suitable for most pull requests.

Deep read of the code changes: suitable for most large pull requests.

Synchronously review one-to-one with the author: suitable for giant pull requests.

Lastly, reviews should be public. If the reviewer and author meet in a video call or in a room, the reviewer should summarize the discussion in a PR comment. This helps everyone looking at the PR later and ensures we are transparent about the life of the PR.

Our guide calls out important steps embedded in our code review process for maintaining consistency and usability of our public APIs. Changelogs and release notes should provide clear and open communication about project updates, while also managing user expectations and promoting new features. The code review should ensure the PR meets the following expectations critical for public facing APIs:

Have a versioning strategy: If the changes are significant or potentially break backward compatibility, verify that the project is prepared for a version bump in accordance with its versioning strategy, e.g., according to semantic versioning principles.

Highlight deprecations and breaking changes: Clearly mark any deprecations or breaking changes in the PR description.

It is sometimes necessary to reject a pull request, in particular to maintain the project’s scope. When doing so, first begin with thanks and acknowledge the contributor’s needs as valid, even if the contribution doesn’t align with the project’s goals. Then be clear and constructive about why the PR does not fit with the project. Following that, present the author with ways out, such as a workaround or forking the repo. And finally, encourage them to contribute again in the future.  

Our code review guide is a living document that can be edited and expanded as needed, so it can and will change over time. Cesium has designed our guide to be a forward-looking overarching framework, which can then be implemented as specific guides for individual projects. 

We invite anyone to open issues with feedback or submit PRs with suggestions about our new guide in our community repo, which houses the guide on GitHub.

Building Culture and Community with Code Reviews

In December, we announced the release of the Cesium Design Tiler and Cesium ion for Autodesk Revit Add-In and dug into Reality Tiler v2. Did you keep an eye on Saint Nick with NORAD Tracks Santa on Christmas Eve?

The Cesium Design Tiler and Cesium ion for Autodesk Revit Add-In are now available.

Cesium Design Tiler

CesiumJS 1.125 is now available. Highlights of the release include:

Expanded the integration with the iTwin Platform to load GeoJSON and KML data from the Reality Management API. Use ITwinData.createDataSourceForRealityDataId(iTwinId, realityDataId) to load data as the corresponding Data Source. #12344

Deep Dive Workshop at the Cesium Developer Conference

Cesium Releases in April 2025

The Weather Company Brings Forecasts to Military Planning with Cesium

Blyncsy Shows Transportation Agencies the Future of Roadway Maintenance with CesiumJS

Cesium Releases in March 2025

Leveling Up Lighting in CesiumJS: IBL, Dynamic Environment Maps, and Ambient Occlusion

Cesium Releases in February 2025