I, Voyager

I, Voyager is in beta!

Try our beta Planetarium! And please give us feedback at our Forum!

What does “beta” mean for us? I’ve bumped each of our two main project repositories (Planetarium and Project Template) and our four Godot Editor plugins (Core, Tables, Units, and Save) to version v0.1. That’s a big milestone! Practically, it means that our API is mostly stabilized (more on that below) and our code is realistically usable by other developers.

Our API is now generalized to support any orbital system(s), even if our own projects are focused currently on the Solar System. See About and Developers if you want to help make I, Voyager into a better space simulator. Or, if you need to insist “This is not a space simulator!” you can engage with us on X. (Srsly, we need the boost.) We’re also at Facebook and about to start posting at Bluesky.

Shadows (finally…!)

Visually, our biggest recent advancement has been to get shadows working. These are visible now at vastly different distance scales, from the rings of Saturn to small spacecraft. And we even have semi-transparent shadows!

Unfortunately, our system doesn’t work using “Compatibility” renderer, so shadows aren’t present in HTML5 exports. It works using “Forward” renderer so should be available for most projects.

Orbit code and orbit “simulation” roadmap

Our simulator uses orbital elements rather than Cartesian coordinates at its heart (the heart being IVOrbit and small-body orbit shaders). Essentially, our coordinate system is p, e, i, Ω, ω, T₀, μ rather than x, y, z, vx, vy, vz. This means that 2-body (spherical) gravitational dynamics are perfectly accurate forever. Perturbations from 3rd-bodies, non-spherical bodies, and other sources can be applied in whichever coordinate system is most convenient, using coordinate-swaps when needed. Well… that’s where we’re going anyway. This makes implementing simple things like rocket thrust more difficult. On the other hand, implementing a Sun-synchronous orbit is easy — it’s simply a constant Ω-rate! The goal is to make all of this under-the-hood so developers can call apply_thrust() without worrying about it. That’s in our roadmap with a lot of implementation detail already laid out in IVOrbit design and documentation.

We’re really developing two different systems for two different use cases: 1) An accurate replication of the Solar System. This if for applications like our Planetarium and involves mechanics that aren’t needed for typical games and not used by default (e.g., IVRealPlanetOrbit; perhaps we will even implement Ephemerides). But also: 2) A more free-running, anything-can-happen, simulator. This will involve heuristics and selectively applying 3rd-body and other perturbations as needed. It won’t be JPL. But it will do things like orbital precessions and Lagrange points (these exist already but we need code to apply them “on-the-fly”), and also respond reasonably accurately if suddenly there is a rogue planet zooming through the Solar System.

After a few redesigns, we settled on our orbit-defining elements as p, e, i, Ω, ω, T₀, μ so we can support parabolic and hyperbolic trajectories using mostly the same code. Other elements are available but derived. These can now be changed in the editor at runtime…

Code modularity and scene tree construction

For developers, the biggest recent changes are about code modularity and scene tree construction. This is especially helpful for GUI building. We now have 47 GUI widgets — from a simple date/time label to a planet/moon navigation widget that builds itself from simulator content. They mostly just work when added to a Godot Container. Some do require context. For example, “selection” related widgets expect to find an IVSelectionManager somewhere in their ancestry tree.

The physical star(s), planets, moons, etc. (IVBody), and their orbits (IVOrbit), are only constructable via data tables. That’s an historical artifact of simulation development: it was easier to build a data table system than to set 10000s of body and orbit parameters in the editor by hand. It’s in our roadmap to make these also constructable in the editor so “level editing” is possible. I’d really like to have a two-way system where we could build or update data tables from the editor, including from code-generated, fully procedural star systems.

Class documentation

Class documentation is ongoing but completed in many classes, including several documentation “entry points.” These are best viewed from within the Godot Editor, but here are repository links:

• IVUniverseTemplate for scene tree construction.
• IVCoreInitializer & IVCoreSettings for Core plugin init & settings
• IVGlobal & IVStateManager for runtime state management.
• IVBody for the physical 3D world.
• IVOrbit for orbital mechanics.

When will v1.0 be released?

The plan is to stay in “beta” until we have significant external usage and feedback on our projects or specific plugins. Please do let me know in our Forum if you are using these in your own project development. There will be less API breakage in beta development than before (especially compared to the immediate run-up to beta). But I’ll certainly calibrate this depending on external usage that I know about. When developers have given feedback and think it’s ready, we’ll move on to more stable v1.0 releases.

A lot is happening if you follow our development at GitHub! As always, I encourage you to visit our discussion forum and try the newly updated web-based Planetarium. And, please do consider getting involved in our development! I, Voyager is open-source and I’d like to see it become a community effort. Our About has more information for contributors.

We’ve migrated to Godot 4!

I, Voyager continues to grow and improve in tandem with the open-source Godot Engine. In November/December of 2017, the Planetarium was a set of orbiting TestCubes running in Godot 2, which only barely supported 3D. From 2018 to early 2023, the project evolved into an open-source solar system simulation and planetarium using Godot 3 — all the while Godot was evolving into a much more sophisticated development platform and 3D rendering engine. And now, after a wee bit of effort from yours truly, we’ve moved on to Godot 4. As always, this kind of update involves a few steps forward and a few back, but sets us up for the future as Godot continues to evolve and improve.

Our web-based Planetarium is now v0.0.18 running on Godot Engine 4.2.1. Please try it and give feedback! Note that Godot 4.2.1 is still a little rough for deployment of HTML5 applications (as noted above, a few steps back). There are presently issues with lighting and our large solar system scale. You may notice that terminators are way too sharp. On the other hand, Godot 4 handles large numbers of meshes much more efficiently. You can now view our 70,000+ asteroid orbital tracks simultaneously even in the web browser app!

I, Voyager code is now a set of editor plugins

For developers, I’ve restructured our code into a set of Godot Editor plugins. This allows a whole bunch of new tricks including: 1) Our core plugin now manages its own (non-Git-tracked) assets. The plugin will check for presence and version of the ivoyager_assets directory and offer to download and update assets when appropriate. 2) Developers can now specify much I, Voyager functionality in a project-level config file. For example, this file can specify use of a different IVUnits singleton to change unit constants (e.g., METER, which sets the simulator scale).

The solar system simulation and associated GUI widgets are distributed in editor plugin ivoyager_core. This plugin requires one other editor plugin to work: ivoyager_table_importer. There is a third editor plugin, ivoyager_tree_saver, that is not used by the Planetarium but can be used for game-save functionality if you are building a game. Plugin ivoyager_core manages the non-Git-tracked assets directory ivoyager_assets (also kept in the addons directory alongside the plugins). The project structure now looks like this:

planetarium
     |- addons
         |- ivoyager_assets
         |- ivoyager_core
         |- ivoyager_table_importer
     |- planetarium
         |- gui (panels include widgets from ivoyager_core)
         |- more planetarium stuff...
     |- ivoyager_override.cfg (plugin singletons, classes, settings & init)
     |- project.godot
     |- readme, changelog, license, etc...

Or…

my_game
     |- addons
         |- ivoyager_assets
         |- ivoyager_core
         |- ivoyager_table_importer
         |- ivoyager_tree_saver
     |- my_game
         |- gui (panels include widgets from ivoyager_core)
         |- more my_game stuff...
     |- ivoyager_override.cfg (plugin singletons, classes, settings & init)
     |- project.godot
     |- readme, changelog, license, etc...

We strongly suggest developers add the plugins as Git submodules. This way, you can pull updates, checkout any commit, and (important for us!) contribute your own improvements back to us via pull requests — all from within your own project. It does take some learning to use Git submodules (if you don’t already), but this is much better than managing addons by manually moving directories.

I’ll upload these editor plugins to the Godot Asset Library with our upcoming beta release.

Beta and beyond…

With Godot 4 migration complete we’ll be moving to “beta” soon. I’m planning one more alpha release (v0.0.19) with a whole bunch of API-breaking class and function changes (of course I want to minimize these after official release!). I’m also hellbent on fixing our issue #1 lack of shadows bug (sadly, there will be no eclipse on April 8). Then I’ll release our first beta (v0.1, likely based on Godot 4.3) and work to solicit more user testing. Then, who knows? Maybe official v1.0 this summer or fall? Please let me know in our forum if you have plans or interest in using I, Voyager code in your own project! Our transition from beta to official release depends a lot on developer needs. For my own use, it’s somewhat easer to stay in beta for longer allowing breaking changes. However, if I hear from other developers, I’ll work more quickly to lock down the API and move to official release.

Please comment at our Forum!

This is a major update for our core mechanics and content. It’s built on Godot Engine 3.5.2, perhaps our last 3.x update before the big port to Godot 4!

Try the new Planetarium here!

Highlights:

1. Saturn Rings are now shader-based (i.e., programmatically generated by the GPU).
2. Models for the International Space Station and Hubble Space Telescope.
3. Orbit lines for asteroids. It looks crazy if you show all ~48,000 present in the web-based Planetarium (see below) and that’s a small subset of the ~1.14 million we can add!
4. Mouse-over identification of individual bodies (yes, including the ~48,000 asteroids!) and their orbit lines. This involves shader magic that will in the future be extended to almost everything: individual bands and gaps in Saturn’s Rings, individual stars, etc.
5. You can now save and revisit “views” which optionally include target body, camera position, HUDs visibility & colors (e.g., asteroid points & orbit lines), and/or time state.

See the full changelog here.

Screenshots below!

Well, that’s it for core I, Voyager and the Planetarium…

In other news, the code I use to crunch raw asteroid orbit data is now public in GitHub repository ivbinary_maker. It isn’t polished (and maybe never will be) but, if you are so inclined, it will allow you to generate binary files for >1.14 million asteroids (numbered and multiopposition). I don’t know what kind of graphics card you’ll need to show those orbits! This also has the code I use to convert Saturn Ring data from Björn Jónsson (backscattered, forward-scattered, unlit, transparency & color data files) into the “1-spatial-dimension” texture used by the new the rings.shader.

Also, by the way, I’m making a game! It’s set in our Solar System. Well, I have been working on in for some years now. More on that soon…

Please comment at our Forum!

Our v0.0.10-alpha release introduces the Planetarium as a Progressive Web App, or PWA. What is a PWA? You can read about it here. For the Planetarium, it means: Faster revisits due to better browser caching. The option to install the app from the web page, which will give you an app shortcut, super fast start time, and automatic updates. Easier app distribution — it’s just a url link! And much less bandwidth required from our web server.

If you’re on a desktop or laptop, give it a try! (Sorry, we’re not quite ready for mobile devices yet.) Just click the link:

https://www.ivoyager.dev/app/planetarium.html

Our underlying Godot Engine introduced PWA functionality in November. It isn’t quite yet working as it should in official Godot releases. But, as usual, Godot devs are awesome and came through for us. With a custom Godot build we have a PWA! Thanks especially to Fabio Alessandrelli (Faless) for making this feature happen!

About installation: It’s easy to miss if you didn’t already know about PWAs. It works a little differently on different browsers, but on Chrome you will see an ‘Install’ icon in the URL bar. (Not immediately. It appears a little while after the app has already started.) Once installed, you will have app shortcuts on your desktop and start menu (or wherever these things go in your operating system). You can now start the app in near-instant time! It works without internet. It’ll update itself quietly in the background when we post a new version. It’s also quite easy to uninstall if you need to do so.

The benefit for us is that our web server doesn’t have to serve you many MBs of data each time you use the app. This was a bit of worry for us if we ever got popular. Hopefully we are ready for a little publicity and wider use now…

Have fun using the Planetarium! And please do distribute the link above to your friends!

In other news, our Downloads page changed to Developers. We don’t have downloads any more. The Developers page is more focused and hopefully more helpful for developers who might want to contribute to the Planetarium or to build their own projects using I, Voyager.

Also, in late November early December our Forum was invaded by more than a thousand bots. But we fought them off successfully! All is well now so please do sign up on our Forum! Due to higher security settings, however, new registrants will be asked an astronomy question. Here is the answer so you are ready…

Please comment at our Forum!

Built on the new Godot 3.3. See changelog here.

Developers should be happy with modularity and extensibility improvements. Our API is not yet stable (we’re still “alpha”!) but it’s shaping up nicely. My working plan is to stay in alpha until Godot 4.0, then have a short beta phase and official release.

Do have a look at our new Planetarium! I’ve expanded data display with closeable orbital, physical and atmosphere sections:

There are many other improvements and small bug fixes.

Please comment at our Forum!

I think we’re due for an update!

I’ve released two alpha builds since the start of the year. The Web Planetarium is shaping up nicely (try it!). And I feel pretty good about code architecture and how the simulator can support an “extension” game or educational project. I’ll talk about recent progress and my thoughts for future development.

First, I finally understand Godot GUI construction! Instead of attacking misbehaving Controls and Containers with lines of code, I now let them do what they want to do. Good lord! How can something so hard suddenly become so easy? So I discarded our previous Planetarium GUI (a code nightmare) and assembled this in maybe an hour:

OK, I said “assembled” in an hour. But that’s only recently possible due to our new modular GUI widgets. These are bits of GUI that know how to talk to the simulator, and can simply be dropped into Containers:

We have 27 of these widgets now, plus additional GUI “mods” that can make panels draggable, resizable with settings, and/or resizable with drag margins. Here’s another “example” GUI assembled for the Template Project:

The core code also is very modular and extensible. The fundamental object class that orbits (and can be orbited) is the Body, which can have an Orbit, a Model, and other components that set its behavior and appearance. You can extend any of these classes in the ProjectBuilder to have your custom class used in the simulator. Unfortunately, it’s rather terrible from a Godot Editor point of view. You can’t presently use the Godot Editor to build a planetary system. The reason is that I, Voyager builds the Sun, planets and moons entirely by code from data tables (and the ~65,000 asteroids from binaries generated from data tables). In the future, perhaps a developer will be able to build a planetary system either way: by data tables, or by assembling pre-built stars, planets, moons, and space ships in the Editor. In any case, this is a weakness of I, Voyager at the moment.

There are things that I don’t know how to do yet, especially regarding graphics. Item #1 on our issue tracker is our lack of shadows. Yeah, that’s pretty basic! But it’s stumped me so far, and it takes away from the view of Saturn in particular. Speaking of Saturn, we need a rings shader! I, Voyager would benefit from help in this area.

Our roadmap is here. A few of the things I hope to get to this year: 1) You’ll be able to select and visit explored asteroids. Some are already hiding unused in our assets. 2) We’ll have comets, at least as orbital points and traces. 3) And spacecrafts! I’d like to have some real spacecrafts on their real historical flight paths in our Planetarium. We’ll start with Voyager 1 & 2 (of course!), then maybe New Horizons, then — who knows? I think it would be cool to spin the clock back 20 years and find the Galileo spacecraft orbiting Jupiter.

My intension now is to keep the project in “alpha” stage until after Godot 4.0 release (perhaps this summer?). After we port to Godot 4.0, we should quickly go to beta and then official “1.0” release. Our API should be pretty stable by beta. (If I know there are developers depending on it, I will be more careful about API breakage even in alpha.)

If you are working on a project using I, Voyager, or are interested in doing so, please let me know!

Oh! And we recently got our trademark registered with the U.S. Patent and Trademark Office! So one can type I, Voyager® now without getting arrested (although it’s kind of ugly, and not required in most circumstances). I say “we” with the intention that I, Voyager will become both a collaborative effort and a nonprofit entity sometime down the road. More on the nonprofit here.

Please comment at our forum!

You can find us now on Twitter and Facebook! Our handle on both is @IVoygr. Well… I’ve been tweeting and facebooking for one week and we have 24 and 9 followers, respectively. Is that good? Heck if I know. It has not ruined my quality of life (yet) or done too much damage to my ego. I’ll keep at it. Speaking of which…

I need you to promote us!

I, Voyager needs users, testers and developers! Please help me grow the community. Follow us, like us, share us, retweet us, signal boost us, link to us, blog about us, signup for posts by email and forward them, tell your human flesh friends about us, write down ivoyager.dev on scraps of paper and pin them to coffee shop boards next to the restroom. Whatever medium is best for you. I, Voyager needs a community behind it to reach its potential!

Please comment at our Forum!

After a month of work and much help from the Godot community, we now have a web-based planetarium! Follow the new PLANETARIUM link in our main menu or click here.

Why a month? To make a long story short, a bit of I, Voyager code that uses your graphics card to calculate asteroid positions (specifically, numerical approximation of the inverse Kepler Equation) was not agreeable with WebGL1, the JavaScript API that renders 3D graphics on your browser. Godot community member capmn was kind enough to point out the flaw (in our code!). Meanwhile, clayjohn used our misguided Godot bug report to identify an actual bug in Godot, the fix for which is already in the upcoming Godot 3.2 release. In any case, it’s remarkable that this is possible at all! I could never have done it without the Godot Engine and its superb community. I’ve posted screen captures below and more on the Planetarium page…

Earth from the Moon.

Uranus tilted at its crazy 98° to the rest of the solar system. Its moons are an interesting cast of characters.

An abstract! It’s a wide-angle view of Jupiter’s moons and Main Belt & Trojan asteroids.

Please comment at our Forum!

I, Voyager is live on the Download page and at GitHub!
For coders, see project template tutorial here.

Please comment at our Forum!

We are two weeks from launch!

I, Voyager is a free, open-source software planetarium designed for game and educational software development. It features the real, dynamic orbits of planets, moons and asteroids — with much more to come!

I built I, Voyager to be improved, modified and extended by the community. A big part of that is the open-source Godot Engine that runs it. I, Voyager uses Godot’s easy-to-learn GDScript (similar to Python) and can be extended using GDScript, C# or C++. Every line of code in I, Voyager and Godot is open for inspection and change. Godot provides the hard stuff (GUI elements, 3D renderer, etc.) and access to a friendly, knowledgeable and rapidly growing community.

I am releasing I, Voyager under the same permissive MIT License used by Godot permissive Apache Licence 2.0. What does that mean? Projects built with I, Voyager are owned by their creators. You can sell what you make. There are no royalties or fees, and license compliance is relatively simple.

History

My first program was a 2-body orbital system written in BASIC on a VIC-20. I’ve remade that program every ten years or so, each time with more detail and better tools. I didn’t particularly know what a “game engine” was two years ago, but I stumbled into Godot, downloaded it, started coding in late November, 2017 — by December I had TestCubes orbiting bigger TestCubes orbiting one really big TestCube. The rest is polish, — except for the name, which I struggled with for a long time. The starting point was this image. After more than a few working names I finally arrived at “I, Voyager.” It’s a play on Voyager 1 (the spacecraft that took that image) and in honor of the Voyager Program.

Images

Join the community!

Please join our dedicated I, Voyager Forum! You can find our newsletter signup on the main site and downloads here (on Nov 9!). For developers, our repository home will be at github.com/ivoyager.

Happy Voyaging!

Please comment at our Forum!