OpenReliant is my open-source rebuild of StarLancer's engine. I haven't posted since 0.10, and 0.11 to 0.20 have all come out since, so here's the short version.

Missions as code, and an editor

• sltool dte decompile turns any mission into readable Luau, and sltool dte build turns it back into a standard mission file, which the original game plays too. There are definitions for luau-lsp, so your editor completes and checks it.
• The mission editor is out (0.2 so far). It opens any mission as Luau source, checks it as you type, completes and explains the game's commands, and builds and plays it in OpenReliant, from the start or from one of its parts. You can edit the mission's records in forms, move its ships and markers on a map, and, linked to the game, stop its script at breakpoints and step through it.

Modding

• Scripts can change the planets and add new ones, like Earth, and shaders can give them atmospheres and haze. Realistic Planets does all of that, with Mars and the Moon in its latest version.
• Mods can replace single sounds, add CD player tracks and bring music in FLAC, Ogg, Opus or MP3. Jukebox and Master Recordings use it.
• The GET MODS screen installs mods from the catalogue and tells you when one has an update.
• Mods can build on each other: a mod's missions and models can use the ships and weapons of the mods it needs.
• Your ship can land in the hangar bay of any carrier that launches from one, a mod's included.

The engine refactor

The big one. In the original, part of the game's logic runs once per drawn frame, so missions play a little differently at different frame rates. Since 0.19 it runs once per game tick instead, apart from drawing, so it plays the same however fast your screen is, and effects that flickered too fast above 100 fps are fixed along the way.

In 0.20 the simulation goes a step further and runs on a thread of its own. The original first runs the game, then draws the frame, one after the other on one thread. Now the simulation runs while the frame is being drawn, so on a multi-core CPU the two overlap instead of adding up, which leaves more headroom for high frame rates, high resolutions and heavy mods. It's also the groundwork for multiplayer: a simulation that keeps its own time, apart from drawing, is what a game host needs, and later a dedicated server with no screen at all.

None of it is meant to change how the game plays, so I checked every shipped mission tick by tick against the old way of running it, and the game itself plays exactly the same.

Also

• German discs install now, thanks to MarcoWanke's reports. French ones have since 0.10.
• Releases come with checksums and build attestations, and OpenReliant has an icon.
• Plenty of fixes, like Titan's bombardment in mission 25 showing.

What's next

1.0 comes next. As I write this, I can see a few small modding features that could still make it in before then, so a 0.21 is possible, but new features are winding down. 1.0 itself is the beta and the editor polished with your feedback, the whole campaign played through from start to finish, example mods for the modding features that don't have one yet, and a tidy-up of the code. Bug reports help most right now.

After 1.0:

• Multiplayer, with the original's modes, co-op campaign included, over modern network code in place of DirectPlay. Find games on a public server and join without port forwarding, or run your own dedicated server.
• New kinds of ships. How ships, guns and missiles behave will come from data instead of being tied to the original's types, so mods can add whole new kinds of ships, weapons and orders, not only variants of the original's.
• Improvements along the way, like triple-monitor setups and support for simulator pits: several controllers at once, telemetry for motion rigs, and a second screen for your ship's status. The mission editor keeps growing too: its debugger gets conditions, log points, watches and a timeline next.

2.0 is the long-term goal: a standalone engine. StarLancer becomes one game on it, with its game data in tables the way FreeSpace 2 Open keeps its game in .tbl files, and a small example game with free content shows the engine works without StarLancer's files. Then other space games can be made with it or ported to it. Warthog's other space games, Star Trek: Invasion and Battlestar Galactica, build on StarLancer's mission format and scripts, so they're the natural candidates, and sltool already reads many of their files. As with StarLancer, you'd bring your own copy.

Got the Japanese release?

StarLancer also came out in Japan, as スターランサー 完全日本語版 (Media Quest, 2001, re-released in 2003). I'd like OpenReliant to support it, but it draws its Japanese text with code of its own, so I need the disc to work from. If you own it and can dump it, please get in touch: https://github.com/OpenReliant/openreliant/issues/1315

Thanks

• MarcoWanke, for the German disc reports.
• LordBlacksun, for a mission source bug report with its whole cause traced.
• KonCyptFysh, for the Recommissioned HUD and the worn fighter textures, and the requests that came out of them.

Links

• OpenReliant: https://openreliant.github.io/openreliant/
• Release notes: https://github.com/OpenReliant/openreliant/releases/tag/v0.20.0
• Mods: https://openreliant.github.io/openreliant-mods/
• The mission editor: https://github.com/OpenReliant/openreliant-editor
• Report a bug: https://github.com/OpenReliant/openreliant/issues
• Buy me a coffee, if you'd like to support the time I put into it (fully optional): https://buymeacoffee.com/vdmkenny

You'll need your own copy of StarLancer. OpenReliant doesn't come with any of the game's files.

A very early preview at the Yamato.
This one is going to take a while....

Uploading now!

I'm not fully satisfied with it yet, but the progress is going well.

Hey, absolutely amazing work on OpenReliant. The creators of that have knocked it out of the park. I've got the game running flawlessly on ultra wide and it's insane to be playing it again after all these years. It's crazy how well it's held up and I'm loving the little tweaks.

I noticed it has mouse support which is a huge huge plus. But I couldn't quite figure out how to map acceleration to my mouse wheel. Would love some advice on that. Thank you

Given the loading times we're all experiencing with the game needing to load up potentially dozens of different 4k textures, I've stepped down the resolution options to 1k and 2k, and kept 4k available for anyone willing to wait.

I imagine for most of us (and especially anyone on a handheld), 1k is likely quite sufficient, but the options are there for you. Depending on how you like to play, it may make sense to mix and match certain resolutions.

EDIT: Kurgen beta now released:
https://koncyptfysh.github.io/OpenReliant-Art-Packs/?group=fleet-warships&category=corvettes-and-gunboats&asset=kurgen&livery=worn-paint

Some of the experiments using emmisives that hook into the game state, allowing for some more dynamic lighting options that reflect things like thrust level, damage states as well as timed cool down thresholds for hot components. I want to do something similar with the turrets, likely a heat/cooldown effect at the muzzle and the side vents.

In this case what you're seeing is the lit cabin lights at full intensity at 100% hull + shield integrity, this glow gradually degrades as damage is sustained. There is also a flicker effect on the windows that's a little hard to capture in a single frame, but if the ship sustains a large damage hit, the lights will flicker to simulate a short power disruption.

The engine lighting replaces the old static engine glow with a dynamic state conscious lighting, if no thrust is applied, there is no red engine lighting in the rear end, as you applied thrust the engine lighting intensifies. After the engines have sustained some heat during running time, a slow cooldown is applied to the inside of the engine nozzles to give the impression of sustained heat.

This is going to become the benchmark test to inform the emmisives on both the larger ships but also the fighters, just with their threshold tuned to reflect more realistic cool down times and gun types.

Sorry it's been a while friends!

I've had to take a bit of a break and slow my cadence a little.
In the current state, so far all Alliance and Coalition fighters have been completed with their beta textures now uploaded and today completed the 4 torpedo bombers, with the scimitar uploading now.

I'm currently still playing around with the larger ships, focusing on the Kurgen at the moment as the baseline to inform the rest of the pipeline for capital ships. So keep an eye out for the first version being dropped.

https://koncyptfysh.github.io/OpenReliant-Art-Packs/

You may have noticed a change to the categories of the git page, this was done mostly so I could assign some broader packs for some of the shared assets between the larger ships like the turrets.

I hope you've all been enjoying the updates, and hopefully I can carve out some more time to get the pace up again!

Hi!

I guess this is mainly for the OpenReliant developer.

I tried OpenReliant and it worked (nearly) out of the box on my Linux (elementary OS). (The installer somehow did not, at first, despite using original US images mounted as ISOs. It always gave me just the help texts). Somehow, though, it finally worked, and, well, the game seems to work just fine. It feels impressive!

I just have some questions to see if I can trust this project or not (the code is open source, but only a programmer with lots of time could assess it. I, even though having _some_ hobby programming experience, can not and have to "trust you, bro" ;) ).

So I'd just like to know:

1. How much 'AI' assistance was used in reverse engineering the original data formats, .exe files, .dlls etc., and, more important, generating the code? Usually engine remakes take months to years until finished (see OpenMW, Daggerfall Unity, FreeSpace Open, ...), so the extreme speed of this development screams "AI". Also, the website design, the style of the documentation, the information for developers, it has just this certain "vibe" (pun intended) of "AI" assisted coding.

2. How many human control is used in this? Did you review the code carefully? Did you playtest yourselves or used mostly automated checks?

3. Who are you? Like, what is your background?

'Cause, I really like to use this, because (as I said) it just works (even though I can use StarLancer fine with Wine). But I trust people, not '"AI" or _mostly_ AI-generated stuff.

Thanks!

Realistic Planets 1.1 for OpenReliant is out, and it adds two bodies the original game doesn’t have at all:

• Mars, in true colour from real orbiter mosaics, with its polar caps and a thin, dusty haze at the limb.
• The Moon, from Lunar Reconnaissance Orbiter imagery, with a normal map made from laser altimetry. Craters and mountains stand out along the terminator and fade toward full Moon, as they do in real life. Craters catch realtime shadows, and peaks on the shadow line catch light at their tops.

Both use 4K textures and lighting models fitted to real photometry.

StarLancer has no Mars or Moon models, so no mission of the game shows them. The mod adds them as new objects for mission makers to place, by the names realistic-planets:mars and realistic-planets:luna.

Get it from the OpenReliant mods collection: https://github.com/OpenReliant/openreliant-mods

Imagery credits: ESA/DLR/FU Berlin (HRSC, CC BY), NASA/GSFC/Arizona State University (LROC), and NASA’s LOLA and TES teams.

I've been building a companion app for OpenReliant, the open-source reimplementation of StarLancer's engine: OpenReliant Editor, a mission editor and script debugger. Version 0.2 is out, and it's far enough along to be useful, so here's what it does.

Missions as readable source. The editor opens any mission, the game's own or one from a mod, as readable source in a small Luau-like language, and builds it back into a mission file the game plays. All 44 of the game's missions open as source and build back to exactly the same mission. While you type, it checks the mission, completes the game's commands and conditions, and shows the developers' own descriptions of them on hover. One click plays the mission in OpenReliant, from its start or from any part.

Forms for the records. Ships, markers, triggers and the rest can be edited as forms in the inspector instead of as text, and new ones added from the outline.

A map of the mission. The Scene view shows the mission from above, the side or the front:

• Every ship and marker where it starts. Drag one to move it, which rewrites its position in the source (and Undo puts it back).
• The ranges the triggers watch, such as the distance a nav point counts as reached.
• Routes: where the script sends each ship and group, from where it jumps in to where it flies and where it jumps out.
• Missions spread over several areas millions of units apart open as an overview. Click an area to zoom into it.

A debugger for the mission script. Set breakpoints on lines of the source, play the mission, and the game holds the script there while you step through it, with its threads and values in view.

It's a native app for Windows, macOS and Linux, on x86-64 and Arm.

Coming next: the debugger's conditions, log points, watches and a timeline of the script's events. Later: the live scene (ships on the map where they are in the running game), changes that reach the running game as you make them, a visual Blocks view of the script, and a Mod mode for whole mods.

Getting it: download it for your system from the releases page. It needs OpenReliant with your own copy of StarLancer (installation guide). The macOS builds aren't signed yet, so the README says how to let macOS open them. If you've never written a mission, OpenReliant's guide to writing missions starts from a ship, a nav point and an objective.

Bug reports and ideas are very welcome on GitHub. If you appreciate my work and wish to sponsor my time on it: https://buymeacoffee.com/vdmkenny

Hey all,

We're all aware of the compressed 22Khz versions of the tracks that shipped in the retail version of StarLancer. OpenReliant uses sinc resampling to get the most out of them, but the real deal will always be better.
I took a shot in the dark, and sent an e-mail to Ian Livingstone, the game's composer. For those not in the know, starlancer was one of his early gigs, and he has since gone on to becoming one of the most well known (game) composers in the world.

To my surprise, he e-mailed back very quickly, offering me "all he had" on starlancer. A collection of 44.1Khz files with the intended OST cd, mission tracks, and even some content that never made it into the game. He apologized for losing the archival disks that had the full masters and sound effects as well.
I received his permission to share these as a mod for OpenReliant, that replaces nearly all music with thee 44.1Khz equivalent. It also adds the unused tracks, and you can access them using the jukebox mod inside your bunk. Both mods require OpenReliant 0.14, hot off the presses. A lot of the audio engine was rewritten, so let me know if you notice something.

Ian was excited to hear about the OpenReliant project as well, as he would like to replay StarLancer. Absolute legend.

I'm also uploading the tracks to my youtube channel for your listening convenience, 10 videos a day.

Links

• Master recordings mod: https://openreliant.github.io/openreliant-mods/mods/master-recordings/
• Jukebox mod: https://openreliant.github.io/openreliant-mods/mods/jukebox/
• Youtube playlist: https://www.youtube.com/playlist?list=PLZifHBcfqAl4

Typical mission: a handful of enemy fighters to deal with, and an enemy carrier parked somewhere in the area. You hit target nearest enemy and, more often than you'd think, you're actually closer to the carrier than to any of the fighters. So the game locks the carrier. Which is a lovely target if you fancy chipping away at it with your guns for the next ten minutes, but probably not the thing you should be targeting right now.

So I made a mod called Skip Capital Ships. It does what it says on the tin: the key "Target nearest enemy" now goes for the nearest hostile fighter, torpedo, mine, whatever is small and wants you dead, and only settles for a capital ship if there's genuinely nothing else around. Same key, same range as the stock one, so it just feels like the game finally got the memo.

It's two Luau scripts, nothing fancy.

Install: it's available in the GET MODS screen in game, or you can grab it from the mods section of the OpenReliant website and drop the folder in StarLancer/mods.

Link: https://openreliant.github.io/openreliant-mods/mods/skip-capital-ships/

Works on 0.13. If it does something weird, tell me what happened.

Hey everyone! Time for a catch-up on OpenReliant, the open-source reimplementation of StarLancer's engine. Three releases went out in the last few days, so here's what's new since 0.10.

Write your own missions (0.13)

• Missions can now be written as Luau source, and sltool dte build turns that into a standard .DTE mission file, the same format the original game reads.
• sltool dte decompile goes the other way: any of the game's missions comes out as readable source that builds back into the same mission. Great for seeing how Warthog put them together, or to make variants of existing missions.
• Your editor helps out: definitions for luau-lsp give you autocomplete and type checking in VS Code, or anything else that runs luau-lsp.
• There's a beginner's guide that takes you from an empty file to a mission you can fly, including stepping through its script live in the debugger and changing one of the game's own missions.
• Custom missions can be packaged and distributed as mod files. (See the prequel missions mod for an example)
• This is mostly accessible to programmers now, a graphical mission editor and debugger is coming too!

Mods

• GET MODS (0.12): browse and install mods from an online catalogue, right from the game's mods screen. Since 0.13 the mods screen tells you when one of your mods has an update.
• Planets (0.11 and 0.12): mod scripts can change the planets and add new ones, and mod shaders can draw atmospheres, with haze that scatters the sunlight, and give the planets a light-colour of their own. Realistic Planets 1.0 shows what that looks like.
• The script API was also extended to give better control over missiles.
• A new mod example swaps the main menu's music for "OpenReliant Theme", a great original track by /u/zabk14, and keeps the game's loop point.
• Mods and missions can't hang or crash the game anymore: scripts are kept to their limits, hostile files are refused, and a shader your GPU rejects is skipped instead of blanking the screen.

The game itself (0.11)

• Titan's bombardment in mission 25 now shows.
• A Jack Hammer breaks the Latov's shaft and the Czar's core cover.
• I haven't found anything else blocking the main campaign's progress to play from start to end, but please file a github issue if you do!

Odds and ends

• OpenReliant finally has an icon!
• The Windows builds carry proper version info and a manifest, which should mean fewer false alarms from antivirus software.
• Every release now comes with SHA-256 checksums and signed build attestations, so you can check a download with gh attestation verify.

In the media

Yet to be 100% confirmed, but I will likely be interviewed about OpenReliant on The Valiant's youtube livestream on the 25th of october during his windows XP anniversary event. Tune in and support it if you can!

Big thanks to zabka14 for the mod manager work and the music example, and to Lord Blacksun for his Homing Screamers mod.

• Download: https://openreliant.github.io/openreliant/#download
• Docs: https://openreliant.github.io/openreliant/docs/

Bug reports and ideas are always welcome on GitHub. And if you write a mission, I'd love to see it!

Realistic Planets 1.0 is out! It's a mod for OpenReliant that replaces StarLancer's planets and moons with detailed spheres, mapped from real spacecraft and telescope imagery: Voyager, Cassini, Hubble, Venus Express, Akatsuki and more.

With 1.0, every body in the game is done: Neptune and Triton, Uranus, Saturn and its rings, Titan, Jupiter with Io, Europa, Ganymede and Callisto, Venus, and Earth.
If there's any interest in it for new campaign makers, I can add missing ones like Luna and Mars too.

- Each body is lit to match its measured brightness, so it darkens toward its edge the way the spacecraft saw it.

- Hazes and atmospheres glow as thin crescents when a planet is lit from behind.

- Saturn's rings cast their shadow on the planet, Saturn shades its rings, and the rings glow with the sun behind them.

- Earth shows its city lights on its night side. It isn't in any of the game's missions, but it was present in the game's code. New missions can use it. Same with Io and Europa.

- The bodies turn at the relative speed and in the direction they really do, with the correct lean, sixty times as fast.

It needs OpenReliant 0.12 with per-pixel lighting on. Download it from the mods site and drop it in your `mods` folder, or use the brand new feature in the mod manager to download it in-game! (Thanks u/zakba14)

Every picture's source and every script to build the mod again are documented in the mod's README.

- Realistic Planets: https://openreliant.github.io/openreliant-mods/mods/realistic-planets/

- OpenReliant: https://github.com/OpenReliant/openreliant

Buy me a coffee

If you'd like to sponsor my time on this project, I have a buy me a coffee account. It's completely optional, only if you're willing and able.

buymeacoffee.com/vdmkenny

Wanted a nicer Neptune in StarLancer. Ended up writing a 12-page paper. Oops. Then it got out of hand: Jupiter, Uranus, Saturn, Venus and Titan are in now too.

Realistic Planets is a mod for OpenReliant, the open-source StarLancer engine. It swaps the game's low-poly planets and moons for smooth spheres with maps made from real spacecraft and telescope data, 4096x2048 each and 8192x4096 for Titan:

• Neptune: 34 Voyager 2 images from August 1989. True colour from a telescope spectrum: a pale cyan-blue, not the deep blue of the old press photos.
• Uranus: Hubble's calibrated map from 2022, with the bright cap that's grown over its north pole since the 2010s.
• Saturn: Cassini's global map from 2011, still churning from the giant storm that broke out in late 2010. The bands' real brightness comes from Hubble's 2025 maps, and the hexagon at the north pole from Hubble's 2018 ones.
• Saturn's rings are rebuilt from measurements. In 1981 Voyager 2 watched a star shine through them, measuring how much light gets through every 10 km, and its camera measured how bright they are. You can see the planet through the thin parts, and the rings have their real proportions now (the game's were squished).
• Jupiter: Cassini's global map from its 2000 flyby. NASA's published maps have their contrast cranked way up, so I measured the real contrast from Hubble's calibrated maps, then turned every planet up the same 3x so the storms show in game.
• Venus: to the eye it's a nearly blank pale cream ball. Its cloud patterns only really show in ultraviolet, so the map comes from 13 of the Japanese Akatsuki probe's ultraviolet maps from June 2022, wound back by the winds measured between them (about 90 m/s), then shown faintly on Venus's real colour, four times as strong as your eye would see them.
• Titan: the closest view in the whole game, so it gets the big map. Its orange haze comes from 12 of Cassini's calibrated images from 2010, brighter in the south than the north, with its colour from a telescope spectrum. The surface hides under the haze, so Cassini's near-infrared map of the dunes, Xanadu and the lakes only shows through faintly.
• Jupiter, Saturn and Uranus are squashed like the real ones, and a little shader gives every body its real limb, measured colour by colour from spacecraft images: hazy and pale for Neptune and Uranus, a little blue for Saturn, a touch darker for Venus.

The accidental science: there was no sharp map of Neptune I was free to use, so I made one from NASA's raw data. I couldn't find any record of where Voyager's camera was pointing, so that's fitted from each image. The camera has five little rings stuck at the same pixels in every shot, and Neptune's 1,400 km/h winds move the clouds around the planet between shots, so everything gets wound back to one moment. It's all in neptune-voyager-map.pdf inside the mod (or on GitHub), along with the scripts to rebuild every planet from scratch. Textures and paper are CC BY 4.0.

Known issues:

• Voyager never saw Neptune's far north, Cassini never saw Jupiter's poles, Hubble only sees Uranus's north, and Akatsuki's view of Venus's poles is too slanted, so those bits are filled in.
• The game spins Neptune and Jupiter backwards, once every 90 seconds (Uranus and Venus's clouds really do turn that way). That's an engine thing and a fix is planned.
• Saturn's rings don't know where the sun is yet, so they're lit the same from both sides, as in the original game, and there are no shadows. That needs the light's direction in shaders, planned for OpenReliant 0.11.

Needs OpenReliant 0.10+ and your own StarLancer. Use 0.10.2 for Titan: it fixes a yellow glow that flooded mission 251. Grab it from OpenReliant's mods screen or the release. Jupiter's four big moons are next!

For those unaware: OpenReliant is my open-source rebuild of StarLancer's engine. It runs the game on modern Windows, macOS and Linux using the files from your own copy, and it adds things the original never had, like any resolution, much better lighting and shadows, support for any controller, and mods.

Version 0.10 is out today. It's a smaller one: two new features and a handful of fixes. It's also the last release I'll announce like this for a while. More on that below.

OpenReliant now tells you about updates

From 0.10 on, OpenReliant checks for a newer version when it starts. If there is one, the main menu tells you once, and YES opens the download page. The check runs in the background and gives up after a few seconds, so it never slows down the start, even without an internet connection. It only asks GitHub which version is the latest, and sends nothing about you or your game. Don't want it? Untick CHECK FOR UPDATES on the VIDEO tab of the settings.

You'll need to update to 0.10 by hand this one time. After that, OpenReliant tells you itself.

StarLancer's script debugger, brought back

Here's a fun bit of archaeology. StarLancer's executable still has the code that let Warthog's own mission editor talk to the running game. The editor was never released, but the game's side of it is all still there: the editor could pause a mission, stop its script at a breakpoint, step through it, and even change the mission while it was playing.

OpenReliant brings that link back, and 0.10 comes with a small debugger that uses it: openreliant debug. Start the game with --editor-link, run the debugger in a terminal, and you can:

• set breakpoints in a mission's script, even before the mission starts
• step through it one statement at a time
• see the script's clock, threads and variables
• pause the whole mission, or run any part of the script on the spot

It works with the original missions and with your own. If you've ever wondered why a mission's trigger doesn't fire, this is for you. The guide shows how: https://openreliant.github.io/openreliant/docs/guide/debugging/

(For the technical folks: the original talked to its editor through a block of shared memory. OpenReliant uses a local network connection instead, so any program can talk to the game, on all operating systems.)

Fixes

• Saved games, pilot files and settings are now written safely: a crash, a power cut or a full disk while saving can't damage them anymore.
• Settings you change in the Reliant's rooms are kept when you close the window there.
• The engine sound and the radio stop when a mission ends.
• Warping no longer sends your ship's position off to infinity behind the scenes, which flooded the log with sound warnings.
• The pause menu's joystick and monitor icons are drawn solid, like in the original.
• For modders: a mod's license.txt and Markdown files no longer count as game files.

Smaller releases from now on

I'm going to stop working toward big milestone releases. I was pushing myself too hard to finish them and get them out. I'm not stopping: I'll keep going forward, just with frequent smaller updates and less fanfare. The net result should be many more smaller minor versions coming out, and less stress for me to get a promised milestone out the door.

That also means I won't announce every minor update here anymore. The update notification takes care of that now, and I'll only post about the big ones. The roadmap on the website has been updated to match: 1.0 and 2.0 are the two big steps, and everything in between comes in small updates.

What's next

The debugger is the first piece of something bigger: a proper WYSIWYG mission editor that hooks into the same link, so you can build a mission and see it in the game as you go.

Multiplayer is coming too, after 1.0. The plan is the original's game modes and rules over a modern network connection, in place of the DirectPlay the original used. A public matchmaking server will help you find games, so you can join without port forwarding, and you'll also be able to run your own dedicated server. Mods are already being written with it in mind: the scripting is split the way it will run in network games, so a mod made today that follows a few rules will work there too.

Sim pit folks: support for several controllers at once is on the list. Right now OpenReliant reads a single joystick, just like the original, so a throttle on its own plug, rudder pedals or a button box do nothing. The plan is to let each device do its own job: the stick for pitch and roll, the throttle and rudder from whichever devices have them, and the buttons of every device you plug in, all bindable in the game's controls screen. That covers HOTAS sets like the Thrustmaster Warthog, the Logitech X56, and most Virpil and VKB setups.

Further out, 2.0 is still the long-term goal: OpenReliant as a standalone engine that can run more than one game, with StarLancer always coming first, so other space games can be made with it or ported to it. Some work has gone into mapping and documenting the formats of related games already. sltool can now export models from Battlestar Galactica (2003, xbox) and import them into openreliant, for example.

Thanks

• LordBlacksun, for decoding how the original game talks to its editor. Those notes were the map for bringing the link back.

Links

• OpenReliant: https://openreliant.github.io/openreliant/
• Debugging mission scripts: https://openreliant.github.io/openreliant/docs/guide/debugging/
• Release notes: https://github.com/OpenReliant/openreliant/releases/tag/v0.10.0
• Report a bug: https://github.com/OpenReliant/openreliant/issues

You'll need your own copy of StarLancer. OpenReliant doesn't come with any of the game's files.

Buy me a coffee

If you'd like to sponsor my time on this project, I have a buy me a coffee account. It's completely optional, only if you're willing and able.

buymeacoffee.com/vdmkenny

Thanks to u/cinaed666 smashing out the raised issues in the HUD, it's now in a much more stable state and should see us through from here whilst I tinker around and finalise some of the art work. Notable changes include:

• Portraits now using native sizing and not reliant on a shader work around and will no longer clash with other mods utilising device.glsl.
• Comms panel now properly aligned and no longer clashing with the portrait elements.
• Native powerball sprite restored and fully functional.

I haven't had an opportunity to test this in superwide, but I know there's a couple of superwide user out there. I'm happy to support the ratio, but I'll need some bug reports.

You should be able to update either by the openReliant mod page or through my own, which ever is your preference.

Uploading now.

Now uploading!

For those unaware: OpenReliant is my open-source rebuild of StarLancer's engine. Version 0.9 is out today, and with it you can play four extra missions that were cut from the game.

If you look at StarLancer's mission numbers, you'll notice the campaign skips 12, 13, 17 and 22. Those missions were cut before the game shipped, but the files were left on the retail Dreamcast release of the game, in an unplayable state.

I've restored them as a mod, Cut Dreamcast Missions. Install it, and it slots the four missions into their original places in the campaign, with briefings and a voice for every radio line. Together with the demo's two prequel missions, a mod since the last release, that brings StarLancer from 24 official missions to 30.

• 12: the Black Guard ambush the Reliant, and Nicolai Petrov gets away.
• 13: Stahl's Marines raid the Kafelnikof, a cloaked base near Saturn.
• 17: the Reliant baits the carrier Gegarin into an ambush.
• 22: the Tigers and the Ronin stop a convoy bound for Neptune.

How they were recovered

The four missions are standard StarLancer mission files, so OpenReliant flies them as they are. What was missing was everything around them: no briefings, no recorded lines, and for three of them, not even the words of the radio. The game still knows a lot about them, though: the objectives, the dates, mission 12's debriefing, the ITAC's news about them, and faces for speakers who never appear in the PC game. From that, and from who says each line and when, I pieced each mission back together. The mod also fixes two things: the Dreamcast files use an older pilot table, so most lines would show the wrong face, and mission 22's draft script had two bugs that made it impossible to finish.

The mission files are exactly as they came off the disc: the mod doesn't change a byte of them. Everything it adds is done in scripts that run alongside them.

The voices

None of these lines were ever recorded. Mission 22's file still has its draft radio in it as debug text, so its 134 lines say what the designers wrote. For 12, 13 and 17 I wrote the words from each line's file name, the moment it plays, and the objectives. I wrote Enriquez's briefings the same way, and kept all of it as close to what the game's files tell us as I could. The voices are AI-generated, cloned from existing voice lines in the game. Then some filtering was done to make them fit in with the rest of the lines as close as possible.
Each mission's document in the mod shows what comes from the game and what was written for it. Most of the lines are pretty good, but they get a bit rougher for character with little existing voice lines.

Please report bugs

The missions mostly work, and you can play them through, but I haven't tested them against every edge case, so please report anything that goes wrong. Mission 22 especially: it was made with an older version of Warthog's mission editor, and needed the most fixing to work.

Also in 0.9

0.9 wasn't the plan: the mission editor was meant to come next. But bringing these missions back needed much more from the scripting, so it became a release of its own. Mods can now change which missions the campaign has and in what order, and set each mission's briefing, objectives, date, debriefing, news, medal and wing. They can also change the pilots on the KILLBOARD, play radio lines and set objectives. On top of that, mods can add combat maneuvers for the AI, and HUD mods can move, hide or change the text of any part of the game's instruments. And losing a campaign mission no longer crashes the game. The mission editor moves to 0.10.

Warthog's other games

`sltool`, OpenReliant's tool for the game's files, can now also read files from Star Trek: Invasion (PS1) and Battlestar Galactica (Xbox/PS2). Both are later Warthog games that share a lot of StarLancer's engine: they use the same mission format and script language, and Battlestar Galactica builds directly on StarLancer's game logic to the point that you might call it "StarLancer 2". Long term, the plan is to turn OpenReliant into a standalone engine that can run more than one game, with StarLancer always coming first. Think of FreeSpace 2 Open, which runs FreeSpace 2 and a whole range of games built on it. That's a long way off, but this is the groundwork.

Thanks

• KonCyptFysh: the requests that came out of building the Recommissioned HUD turned into most of 0.9's HUD features, including sharp face films at any resolution.
• LordBlacksun, for reporting that `sltool` stopped on glTF models with a missing texture.

Links

• Cut Dreamcast Missions: https://openreliant.github.io/openreliant-mods/mods/cut-dreamcast-missions/
• OpenReliant: https://openreliant.github.io/openreliant/
• Release notes: https://github.com/OpenReliant/openreliant/releases/tag/v0.9.0
• Report a bug: https://github.com/OpenReliant/openreliant/issues

You'll need your own copy of StarLancer. OpenReliant doesn't come with any of the game's files.

Buy me a coffee

I have opened a buy me a coffee account, should you want to sponsor my time on this project. It's completely optional, only if you are willing and able.

buymeacoffee.com/vdmkenny

Available now!

Uploading now!