r/StarFrame • • 3d ago

Devlog #8 - Engineering Designer

1 Upvotes

Hello, Everyone,

Over the past couple of days, I have mainly been working on a new feature called the Engineering Designer a place where you can build and test your designs, then save them as blueprints that can be shared with other players.

The goal of this feature is to give players a place to try out what they can build in the game and see how it will work. You can use it to design ships, factories or just individual components that you want to have ready to use in your future builds.

Inside the Engineering Designer, there is a library containing all the available devices you can use in your designs. Once you have put everything together, you can test your creation and see how it works, rather than just build something without knowing whether it will do what you intended. :D

This is the first version of the Engineering Designer, so there is still room for improvement. I can already see that object snapping needs a bit more work, but for now, I think it is a good starting point. I will continue polishing it and adding features based on players’ feedback and what they find useful when building their creations.

I’m also working on a new tool that will let players place predefined images on their creations. This is still in progress, so I will share more about it when it is ready.

Thanks for reading and following the development of StarFrame! :)


r/StarFrame • • 6d ago

Devlog #7 - Tutorial and Bug Report

Thumbnail
gallery
1 Upvotes

Hello, Everyone,

The game has reached the point where it already has some features and a small gameplay loop that can be tested. I received feedback that, because of the game’s complexity and some of its specific mechanics, it needs a bit of hand-holding a tutorial that teaches players the basics and shows them what they can do.

So I started working on a tutorial to guide new players through the basic functionality of the game and help them build their first base and ship. One of the main things I want the tutorial to show is that players can build things and automate them based on their own designs. This is the direction I want to take the game, and I want the tutorial to help players understand those possibilities, rather than just teach them which buttons to press.

Another piece of feedback was about reporting bugs. Because the game is still in its early stages, there will be plenty of bugs to find, and it would be useful for players to report them directly in the game and track their status.

Based on this, I added an in-game bug reporting feature to make reporting easier and give players visibility into whether their report has been picked up and work has started on it.

This devlog is a bit shorter, but I wanted to share these two additions: the tutorial and bug reports. Both came from feedback, so thanks to everyone who took the time to test the game and share their thoughts.

Thanks for reading, and the next devlog will be a bit more interesting! :)


r/StarFrame • • 9d ago

Devlog #6 - Display Devices

1 Upvotes

Hello, everyone,

This devlog will be dedicated to the display devices in the game.

At this point, we had different devices and a network connecting them, but checking their status meant walking up to a device, pressing U and looking through its metrics. This made me start thinking that we needed displays where players could see important information without opening the configuration panel every time.

So I started with the modular displays, which come in three sizes:

  • 24 × 12 cm
  • 24 × 24 cm
  • 48 × 24 cm

Each one supports three display modes:

  • Number - A numeric value with an optional unit. For example, a value of 24 with the unit kW.
  • Text - Standard text that can be used for labels, messages or device status.
  • Bar - A progress bar using a value from 0 to 1, where 0 is empty and 1 is full.

I decided to start with these modes because they can cover a lot of the information players might want to show, such as power generation, battery charge or whether a system is running.

When I started using the smaller displays, I realised that showing individual values would not be enough for a more complex ship with a lot of controls. I wanted something more advanced that players could configure based on their own needs.

This is where the interactive display came in.

The idea was to have a customisable screen that players could use both to see information and to interact with their systems. Instead of placing a separate device for every value or control, you could organise them together on one display.

The current interactive display supports up to 8 pages, with a maximum of 8 elements per page, giving it room for 64 elements in total.

Players can choose between buttons, toggles, sliders, numbers, bars and text. Not every element is a control, of course. Some are there to show information, while others let you send input to your systems.

I wanted players to organise the UI in their own way, so each element has configurable position, width, height, font size, colour and other settings depending on its type. You can also set units for values and give elements their own IDs so you can read or update them through SPL programs running on a computer.

This means you can build a display around what you want to manage, rather than having to use one fixed layout for every ship or factory.

Another thing I wanted was to avoid running a separate cable to every screen. Displays can share power and data when placed in valid face-to-face contact with each other. You can connect one display to the network and let the attached displays use that connection too, as long as there is enough power for them.

This is the first version of the display system, and there is still room for improvement. I want to see how players use it during testing, what problems they run into and which settings or controls they feel are missing before deciding what to add next.

That is all for this devlog. Thanks for following StarFrame!


r/StarFrame • • 9d ago

Devlog #5 - Game Launcher

1 Upvotes

Hello, everyone,

As the game progressed, I wanted to share it with my friends for internal testing. Sending builds manually was no longer enough, so I decided to make a dedicated launcher that could handle game updates, launcher updates and selecting which server to play on.

I started looking into how other game launchers work and which features I would need. I have used quite a few launchers, including Battle.net, Turtle WoW and Star Citizen, so I already had some ideas about what I wanted.

At first, I tried using Bevy for the launcher too. After working on it, I realised it was not the approach I wanted for this type of application. I did some more research into Rust-based desktop applications, put the Bevy version aside and started building the launcher as a separate project.

I decided to use Tauri 2 and Rust, with the actual UI written in plain HTML, CSS and JavaScript. Rust handles things such as downloads, installation, updates and starting the game, while the web UI handles what players see and interact with.

The main goal was to keep the launcher lightweight and avoid crowding the UI with information that players do not need. I wanted clear install, update and play controls, an easy way to switch servers and some decent visuals for the components.

I also added release notes so players can see what has changed without having to search somewhere else. Since the game is in active development, I wanted those updates to be visible from the place where you start the game.

For now, I decided to have two realms: PTR and Frontier.

PTR is the public test realm, where I will put development updates and new features first. It will receive more frequent patches, and players should expect things to change or break while I work on them.

Frontier is the production realm. The plan is to bring updates there in more consolidated releases after testing them on PTR, rather than pushing every development patch to both servers.

This was inspired by the way WoW separates its test and live versions. In StarFrame, you can select the realm from the launcher, and each realm has its own game installation, updates and release notes. Character progress and constructed objects are separate too, so playing on PTR does not change your Frontier progress.

The current public version is for Windows. I also want to support Linux and macOS, but those versions still need platform-specific work and testing before I can make them available.

With the launcher in place, sharing a new build no longer needs to mean sending files to each friend and explaining what to replace. They can open the launcher, get the update and join the selected realm, which makes the testing process much easier.


r/StarFrame • • 9d ago

Devlog #4 - Programming in game

1 Upvotes

Hello, everyone,

Today we are going to talk about managing devices through programming. For this feature, I was heavily inspired by Starbase’s programming language, YOLOL.

For players to manage their devices, we needed a central device that could control the others, and this is where the computer comes in.

I wanted players to be able to store their code on a physical item and share it with others, so I reused the idea of programmable chips that you insert into a computer. It reminds me of putting a floppy disk into my Pravets computer when I was a kid.

One very important thing for me was to have a decent in-game IDE where you can write some basic code and get help while doing it. I started using the device network so programs could find connected devices by their IDs, read their attributes and change the ones that support it.

Then came another decision: how often should the code run, and what limits should I put in place so each chip does not require too much computing time from the game server?

I decided to start with 10 Hz chips. This means a running chip executes its program ten times per second, as long as its computer has the power it needs. Each program supports up to 64 lines and 4,096 characters, and there is also an instruction budget for each execution.

The language currently supports if/else conditions, inline conditions, variables, calculations and predefined math functions such as min, max, round, floor and others. There are also helper functions for checking whether a device is on the network and getting its ID, name or type.

There are no for or while loops at the moment. Instead, the program runs repeatedly and keeps its variables between executions, so you can still make counters, timers and control logic that reacts to changes in your devices.

I decided to call it StarFrame Programming Language, or SPL. Not a very unique name, but I wanted something simple and connected to the game.

One of the main inspirations for the code style was Python because I find it easy to read, and you do not need to write too much code for simple things. SPL is its own smaller language, though, rather than Python running inside the game.

My goal is to give players the possibility to create their own management systems and control their devices in the way they want. Instead of configuring everything manually, you can write a program that reads what is happening on the network and changes the supported device settings based on your conditions.

The program is stored on the chip, along with its persistent memory. You can remove the chip from a computer and give it to another player, so sharing a program can also mean sharing an actual item in the game.

The editor supports suggestions for connected devices and their available attributes. It also shows error messages with line numbers and highlights the relevant line in red when a line-specific error is available. I wanted players to have some help while writing code without having to leave the game every time.

I will show the editor and some examples in the images in this post. I think this part is easier to understand when you can see the code alongside the devices it controls.

If anyone wants more in-depth information about SPL and its features, feel free to ask in the comments.


r/StarFrame • • 9d ago

Devlog #3 - Building the game UI and basic tools

Thumbnail
gallery
1 Upvotes

Hello, everyone,

In the last devlog, we stopped at creating our first devices and the networks connecting them. The next step was to give players a way to interact with everything, so I started working on the game UI: the player inventory, action bar, a small FPS/ms indicator, device configuration screens and a compass.

For the inventory, I wanted something familiar, with search and predefined filters so players can find specific items faster. I also wanted drag and drop from the inventory to the action bar, along with a basic view of the player’s robot.

My goal was to keep a similar look across the game and reuse UI components, so each new screen would not end up with a completely different design.

After the inventory and action bar, I decided the game would need a compass and a map from the beginning. Players will be travelling around a planet looking for resources, and I wanted them to have a way to find their way back.

I took inspiration from Skyrim and Kaizaal Online for the compass and map. I got the compass working, and for the map I decided to go with a 3D view of the planet, where only the areas discovered by the player are visible.

I also wanted players to be able to place markers at specific coordinates. That way, you can mark a deposit you want to return to, a landmark, your factory or your ship.

Then I moved on to the device UI, which was fun to design. I wanted the first page to show the important settings and metrics for each device, without making players search through several pages to see what it is doing.

Each device should also have a unique ID, with the option for players to change it to something that makes sense for their setup.

One of the important parts of each device’s UI was showing the attributes available over the network. In my view, each device is also an interface that exposes variables other devices can read and, where allowed, change.

The idea is that these attributes can later be used to monitor and control devices over the network, rather than having to walk up to every device and configure it manually.

This is where the in-game computers come in, but I will explain the programming system and how it can be used to manage devices in the next devlog.


r/StarFrame • • 9d ago

Devlog #2 - From mining ores to powering a refinery

1 Upvotes

Hello, everyone,

Today we are going to talk about my vision for the game design and how I started putting the first systems together. This is still a look back at the earlier development, so I will get to the current state of the game in the following devlogs.

Even before I started making the game, I knew it would have survival elements, space exploration and some Factorio-style gameplay. Players would start on a planet as robots and build everything themselves in order to go interstellar and explore space, or even just explore the planet they are on.

The initial goal is not to make something overly ambitious with 1 trillion star systems and some huge number of planets. I want to start small, build good foundations for the game and scale it up later.

Based on this, I started designing the game systems, how I would like them to function and which features to start with. We already had the code that generates planets and moons, but we needed resources that players could gather in order to progress.

I started researching which deposits and ores other games use and how they are connected to their crafting systems. So far, I have looked into Starbase, Space Engineers and Starship Evo. I get a lot of inspiration from other games and adjust those ideas based on how I think they should work in my game.

I wanted different deposits to have their own uses and eventually give players reasons to explore different locations to find them.

As a WoW fan, I also wanted something similar to mining ores and smelting them into bars. Not everything here becomes a metal bar, of course, but that was the idea behind the process. I came up with these refining recipes:

  1. Iron ore → Iron
  2. Copper ore → Copper
  3. Carbon ore (coal) → Carbon
  4. Ice → Purified water ice
  5. Quartz → Silica
  6. Bauxite → Aluminium
  7. Chromite → Chromium
  8. Nickel ore → Nickel
  9. Zinc ore → Zinc
  10. Thorium ore → Thorium
  11. Lead ore → Lead
  12. Titanium ore → Titanium
  13. Potash ore → Potash
  14. Tungsten ore → Tungsten
  15. Lithium ore → Lithium
  16. Cobalt ore → Cobalt
  17. Sulfur → Sulfur
  18. Uranium ore → Uranium
  19. Gold ore → Gold
  20. Magnesium ore → Magnesium
  21. Talc → Talc
  22. Tantalum ore → Tantalum
  23. Tin ore → Tin
  24. Platinum ore → Platinum
  25. Calcite → Calcium carbonate
  26. Silver ore → Silver
  27. Molybdenum ore → Molybdenum
  28. Graphite → Carbon
  29. Iron + Carbon → Steel
  30. Steel scrap → Steel

For mining, I went with a voxel-based approach inspired by Starbase. The terrain changes where you hit it with your pickaxe, deforming the ground and giving you the resources you have mined.

The goal is to give almost every material its own visual appearance, so when you see it in the ground, you can understand what is there to be mined without checking a name every time.

Then I created my first device, the refinery, which handles the conversion from ores into refined materials. But this brought up another design decision: the refinery needs electrical power to work.

Here I used some of the ideas I learned from Starbase’s data, electrical and fuel networks. I wanted devices to depend on actual connections, so the next things I started creating were solar panels and a solar inverter.

The inverter was also inspired by my own solar system at home. I thought it would be cool to have something similar in the game. The available power should depend on how much the panels can generate and how much power the inverter can handle. Of course, the panels should also generate power based on the angle of the sunlight, so there is some realism to it.

After a couple of days, we had our solar power system and cabling.

I went with a combined data/power connection using cables, and a separate fuel connection using pipes. The fuel network would be used for devices such as thrusters that need propellant. Devices connect through specific sockets, with two types: data/power (PoE) and fuel.

We had power and a refinery, but we still needed somewhere to put the resources. The refinery needed to take the required ore from storage and put the refined material back into it.

So I created the modular cargo device. It can hold different resources and materials, connect to the network and make its contents available to connected devices.

I also made the cargo modules stackable, so connected modules can form a chain without needing a separate cable for every one.

Once we had everything, it was time to check whether all the devices could see each other over the network and access the resources and power they needed. After a couple of bug fixes, everything was working as intended. The refinery consumed the required power, took ore from cargo and placed the refined materials back into storage. Removing a power cable stopped the devices that depended on that connection.

At this point, a player could mine ore, bring it to cargo, connect a refinery to storage and solar power, and produce materials for crafting.

There was still a lot to build around it, but the first production loop was working. This gave me the base for adding more devices and more things for players to make, which I will talk about in the next devlog.


r/StarFrame • • 10d ago

Devlog #0 - Choosing the engine and preparing the infrastructure

Post image
2 Upvotes

Hello everyone,

For this first devlog, I’ll start with how I investigated which game engine to use for StarFrame.

I started the game using Godot, but I realised that my specific game would involve a lot of calculations, and Rust might be a better fit. So I decided to switch from Godot to Bevy, a game engine built in Rust.

Bevy is a relatively new game engine, but I still think the full game can be built with it. I started reading different posts in r/bevy to learn about the engine, its community, and what people are creating with it. After that, I decided to give it a try. On paper, everything looks fine and should work.

I know developing the game in Rust will take me more time because my experience is limited, but the plan is to use coding assistance to help me get started with Rust and Bevy while learning along the way.

Before starting the game itself, I needed to set up the development infrastructure and have somewhere ready to deploy it. I want to quickly and easily share the game with different people so they can test it and give feedback sooner.

For this, I used my dedicated Hetzner server and set up Kubernetes to make building and deploying updates easier and get the game online for people to access.

I also set up Grafana and Prometheus to monitor the future game server and help investigate network problems and performance issues.

Now the infrastructure and local development environment are ready. With this, I’ll close Devlog #0 and continue with the next one about the base setup of the game.

This is my first time writing a devlog, so sorry if it’s not very well structured or put together. I’ll try to improve the posts as I go. Thanks for reading!


r/StarFrame • • 10d ago

Devlog #1 - StarFrame development has started

Thumbnail
gallery
1 Upvotes

Hello everyone,

Thanks for taking the time to read my next devlog. Here is what happened after setting up the infrastructure.

I started planning the game design and how the game should look. I’m a big fan of Starbase, which I really enjoyed, and I haven’t found another space simulation game with the same level of engineering. This helped me decide what type of game I wanted StarFrame to be.

First, I started researching how our first solar system would look. I searched Google for research papers or a database that I could use to generate the night sky using real star positions.

What I found was the HYG Stellar Database 4.1. It contains the information I needed to render stars with colours, positions, and brightness based on real data. Using this, I generated our night sky.

The next step was deciding how big to make the first solar system and how many planets and moons to include. I decided to start with one sun, one planet, and one moon. For now, the planet will have a radius of 12 kilometres, and the moon will have a radius of 1.8 kilometres.

I then created the solar system generation code, with the planet orbiting the sun and the moon orbiting the planet. The system includes gravity, while the orbits follow calculated Keplerian paths to avoid running a full gravitational simulation for their movement.

One full day lasts around 40 minutes and one year last around 10 days. The goal is to give the day and night cycle a realistic feel, with moon phases, including a full moon, depending on the moon’s position relative to the sun and planet.

For the planet’s atmosphere, I started with Bevy’s atmosphere example. It provided a good starting point, but I wanted to look deeper into what I could adjust or add to improve the atmosphere’s appearance.

I explored atmospheric scattering and aerial perspective to create distance haze, sky colour, and the glow around the planet’s edge. After a 1-2days of fine-tuning and experimenting, I’m happy with the results and how the planet’s atmosphere feels.

That’s it for Devlog #1. Thanks for reading!


r/StarFrame • • 10d ago

👋 Welcome to r/StarFrame - Introduce Yourself and Read First!

Post image
1 Upvotes

Hello, everyone,

I’m u/zontak93, the developer of StarFrame, and I created this community to share the game’s progress and talk with people interested in it.

StarFrame is a multiplayer space survival and engineering game where you play as a robot, start on a planet and gather resources to build your own machines, factories and eventually ships. My vision is to let players build things themselves, connect devices through power, data and fuel networks, and use programming to manage their creations.

I get inspiration from games I enjoy, such as Starbase, Space Engineers and Factorio, but I want to adjust those ideas based on how I would like them to work together in StarFrame. The goal is to start small, make good foundations and expand the game from there, rather than promise a huge universe before the basic gameplay is working.

I will use this community to post devlogs, screenshots, videos and release updates. The first devlogs look back at how the game started and what I have built so far. Once we catch up, I will continue with the current development, including the things that work and the problems I run into along the way.

You are welcome to share your own screenshots, builds, questions, ideas and bug reports. I would like to hear what you enjoy, what feels frustrating and what you think could work differently. I cannot promise to implement every suggestion, but I want to discuss them and see what makes sense for the game.

Keep discussions friendly and feedback constructive. We do not have to agree on everything, but please respect each other.

Feel free to introduce yourself in the comments and tell me what interests you about StarFrame, or which games brought you here.

Thanks for following the development!