u/wizzard_rick

Strategy games often turn skilled workers into settlement modifiers. While researching colonial Virginia, I learned that many young Virginians were apprenticed to blacksmiths for 3–13 years, usually until age 21.

The skill was not an abstract settlement upgrade. It belonged to the person who had spent years learning it.

That is what I wanted the mechanic in this clip to preserve. Nathan leaves the household at 17 in 1780. Three yearly turns pass without his labor or combat ability. When he returns at 20, the blacksmith specialty belongs to him: he can operate a smithy and produces tools 50% faster.

I am the solo developer of Salt and Soil, a strategy game about one frontier family from 1609 to 1900. The family tree is the campaign, and the free Steam Playtest is open through August 19.

I like maps because they turn lists of dates into spatial relationships. Timelapses take that one step further: compress three centuries into seconds, and a seemingly static map begins to feel alive.

I made this from historical data compiled for the map of my solo-developed game. It shows 147 conventional city-founding dates and ten historic route corridors. Political borders are omitted because no single boundary layer would be accurate across the entire period. The dates do not represent first human settlement, and the routes are not a complete history of colonization and migration.

The map belongs to Salt and Soil, a colony sim about one family living through a changing American frontier. Its public Steam Playtest is open through August 19.

Made a little grappling hook + rope marker for custom scenarios, and also just because I thought it would look cool hanging off the terrain.

The idea is that it represents a rope long enough to climb roughly to a second-storey window or battlement, so I can use it as an actual objective/interaction marker during games.

Very simple build: ordinary hemp twine soaked in superglue so it keeps its shape, with the grappling hook bent from a couple of paperclips.

The paintjob is pretty rough — I wanted to build and test the whole thing in about half an hour. I think it works surprisingly well on the table, though, so I’ll probably make a few more.

These are direct exports from the same renderer I wrote, with the camera, projection, crop and terrain layer locked between all three dates. The political layer uses dated source snapshots and holds each state until the next documented boundary change; it does not smoothly invent borders between dates.

Main geographic sources: Natural Earth, CEC Level III ecoregions, and the Newberry Atlas of Historical County Boundaries.

This is the economic trap I want Salt and Soil to create: in this 1613 household, three tobacco bales will gross 21 money in Jamestown, but the labour that produced the export crop did not grow food. The next-year food projection is already −10, while market food costs 5.

Tobacco is profitable and dangerous for the same reason: it lets the household specialise, then makes survival dependent on buyers, food prices and continued access to the market. The decision is no longer “can I make money?” It is “how much of the family's food supply am I willing to outsource?”

This is a deterministic economy, not an outcome written by the narrative AI. Tobacco bales, stored food and town prices are separate game-state values. The video reconstructs the numbers from this recorded run over the live map; it does not stage buildings or settlement growth.

Historically, the National Park Service notes that Thomas Dale initially limited tobacco cultivation because settlers might neglect basic survival needs. Its account of Jamestown in 1617 describes damaged infrastructure while colonists were dispersed planting tobacco. Source: National Park Service

Would you keep selling tobacco and buy food, or treat the negative food projection as a hard stop?

AI disclosure: generative AI is used at runtime for some family-specific Council prose and choices, and assisted parts of programming

I’m building Salt and Soil, a family strategy game that runs from 1609 to 1900.

These are three attempts at generating the same isometric world. The first was readable but looked like a diagram. The second had the atmosphere I wanted, but roads and buildings vanished into the texture. The third is less lush, but actually works as a strategy map.

During asset generation, every tile begins as an empty diamond. Its coordinates are combined with the world seed, producing a repeatable roll of the dice: same seed + same position = same result

The ground is painted pixel by pixel rather than selected from a folder of finished textures. Several scales of noise create broad colour changes, smaller patches and surface grain. The result is compressed into a short colour ramp, giving the terrain texture without introducing smooth digital gradients.

Then the script adds readable marks. Fields receive small clusters of grass, flowers and exposed soil. Forest floors get darker patches, moss, fallen logs or an occasional clearing. I deliberately moved away from covering every free pixel: details that looked attractive on an isolated tile became noise when repeated across a continent.

The trees are procedural sprites too. Each starts with a trunk and shadow, followed by several overlapping foliage shapes. The seed changes their width, height, gaps and silhouette. Pines use narrowing layers; hardwoods use wider overlapping crowns. Oaks, maples and birches share the same basic construction rules but use different proportions and palettes. Highlights always favour one side, while the opposite side falls into shadow.

Mountains use a stranger process. The script builds a small 3D heightfield from profiles such as ridges, saddles and broken massifs. It calculates the slope, lights the surface, reduces the colours to a pixel-art rock palette, and projects the result into an isometric sprite. Those sprites are then baked into the same atlas as the flat terrain.

A tile also checks its four neighbours. All tiles sample the same map-wide noise field, while shared biome borders receive a seeded curve and a few details borrowed from either side. Roads and rivers are drawn before trees and relief; tall objects are added afterward in back-to-front order so everything overlaps correctly.

The advantage is that I edit the visual rules instead of repainting hundreds of tiles. I can change the palette, tree density or mountain profiles and regenerate the world while keeping the same seed.

The problem is that procedural generation is very good at making every tile interesting. A strategy map needs most of them to stay quiet.

Version 02 is still my aesthetic favourite. Version 03 is the one I can actually play.

This is Salt and Soil, the historical family strategy game I’m building solo.

I wanted a long campaign without making the player an immortal ruler. One turn is one year, and the household’s labour has to be divided between food, buildings, livestock and trade. The founder will die before the campaign is over. The next generation receives the ranch as it actually stands: useful buildings, debts, unfinished plans and all.

Meanwhile the continent keeps changing. Settlements appear, roads connect markets and political borders move. You are not trying to paint that map; you are trying to keep one family viable while the meaning of its land changes around it.

I’m preparing a public playtest for August. The system I most want strategy players to break is succession: whether a decision made by one generation remains understandable—and interesting—after the person who made it is gone.

This is from Salt and Soil, the family strategy game I’m building solo.

I wanted succession to work like a restart without wiping the world. After the children grow up, you can keep the established ranch under an ageing parent, or follow a younger branch inland. The old household keeps thirty years of property but may run out of heirs. The young household keeps its future, but leaves with no barn, no savings and a new family to build.

Both branches stay on the map. You only control one of them.

The public playtest runs August. The bit I most want roguelite players to test is whether this feels like a real fork in a run - not just a character-select screen.

I’m the solo developer of the Salt and Soil. I wanted succession to feel like a life decision rather than a character-select screen: stay with the older household and everything they built, or follow their adult child inland and start again with more time ahead. Both branches remain on the map; you only control one.

The wider game is a historical family and settlement strategy sim rather than a day-to-day Sims-like game. Characters age, form households, inherit property and live through a world that keeps changing around them.

Salt and Soil: https://store.steampowered.com/app/4551060/Salt_and_Soil_A_Frontier_Family_Sim

AI disclosure: the game uses a language model at runtime to write short narrative events from the current game state, and AI tools have assisted me with parts of the code.

I'm making Salt and Soil, a turn-based strategy game where one turn is one year and a single run lasts from 1609 to 1900.

Most turn-based games use turns to give you more control over a short moment. I went in the opposite direction.

You decide what the household will spend the year doing: growing food, building, trading, tending animals, or preparing to move. Then you end the turn and twelve months are gone. There is no way to recover three months of labour because you changed your mind halfway through.

That scale means the simulation has to stay fairly simple. I am not modelling every day of farm work or asking the player to micromanage individual meals. The interesting decisions are strategic: what should this family spend a meaningful part of its life building, and will that still matter twenty turns from now?

History keeps changing the answer. The Starving Time makes food more expensive and closes trade with the Powhatan. The Year Without a Summer hits a household that may already be living too close to the edge. New roads, wars, floods and markets can make an old plan valuable, obsolete or dangerous.

The person who made that plan may not be around when its consequences arrive. Parents grow old, children become workers, the head of the family dies, and somebody else inherits the house, its debts, its relationships and whatever unfinished problem the previous generation left behind.

So the family is effectively the save file. Individual people come and go, but the same run continues for almost three centuries.

What I like about the one-year turn is the distance it creates. You can understand a decision immediately, but you may not understand its real cost until another person is living with it.

For people who play a lot of turn-based games: when a turn represents this much time, what information do you need beforehand for the outcome to still feel like the result of your strategy?

AI disclosure: the current build uses generative AI to draft runtime Family Council narratives and candidate choices. Economy, historical modifiers and applied consequences are handled by deterministic game systems. I also use AI-assisted coding tools during development.

I’m Roman, the solo developer of Salt and Soil, a management game about one frontier family trying to make a living from 1609 to 1900. One turn is one year.

What I enjoy most in tycoon games is the period before I’ve solved the spreadsheet. I’m still figuring out what the market wants, which expenses are quietly killing me, and whether the business I’m building will ever pay for itself.

Eventually, though, I usually find the answer. This production chain is the winner. This layout works. Now I just make it bigger.

Salt and Soil is built around the idea that a good answer should eventually expire.

The California Gold Rush scenario is the clearest example. In 1849, Sacramento starts paying 40% more for manufactured goods. Expanding production suddenly looks like free money. But food now costs 80% more, tools cost 60% more, and transport is getting expensive. The household can be making record profits while becoming dangerously dependent on a market where it can barely afford to feed its workers.

Then history keeps moving.

In 1861, the Great Flood destroys food and timber, nearby settlements stop selling food, and transport becomes harder. In 1869, the railroad cuts effective distance and makes imported tools and goods cheaper again.

The workshop you built twenty years ago is still standing. The family may still be paying for it. But the economy that made it a good idea is gone.

Because the run lasts almost 300 years, the person who chose that business may be dead by then. Their children inherit the buildings, inventory, debts and whatever assumptions their parents built the household around.

It’s a smaller scale than most tycoon games: one household rather than an empire. But the question is the same. How much of the future should you build around today’s prices?

Do you enjoy management games that eventually make old optimisations obsolete, or does that feel like the game taking away something you already earned?

AI disclosure: Salt and Soil deliberately uses generative AI at runtime to create narrative events and choices for the yearly Family Council. The AI reacts to the current family and world state, which is one of the core features of the game. Its gameplay effects are constrained and validated by deterministic game code; it cannot directly alter the economy or write arbitrary changes to the save. I also use AI tools as coding assistants during development.

I'm Roman, solo-dev working on Salt and Soil, a rpg\strategy game about one frontier family living from 1609 to 1900. I've been calling it a survival strategy, although I'm not entirely sure whether survival players will agree with me.

(Sorry about the video quality—I was trying to get the idea across quickly, so the quality isn't great in some parts)

I've played a lot of survival games. The things I remember from them are usually not the exact hunger numbers. I remember the awful shack I refused to abandon because I nearly died building it, or the winter that made me eat everything I had been saving for later.

Salt and Soil stretches that attachment over a much longer period. One turn is one year.

Everyone in the household has to be fed at the end of it. Adults eat two units of food; children eat one. A bad shortage weakens the family. If they are still short the following year, somebody can die. Losing an adult also means losing part of the labour pool that was supposed to fix the problem next year.

There is no chopping animation, and I don't ask you to cook individual meals. You decide what the family spends the year doing: growing food, building, trading, tending animals, or preparing to move. Once you end the turn, you have committed a year of their lives to that plan.

The historical setting then leans on the same household. In 1609, during the Starving Time, food in Jamestown becomes much more expensive and trade with the Powhatan is cut off. Later, floods can destroy stores and stop neighbouring settlements from selling food. Wars and new transport routes change where it is safe or affordable to trade. History is not a separate mission. It changes what the family can do with the resources it already has.

The founder is never going to make it to 1900. Their children grow up, take over the home, inherit its debts and relationships, and eventually leave problems for their own children. You can keep one person alive for a while. The actual run belongs to the family.

So it doesn't have the moment-to-moment panic of a first-person survival game. What I'm after is the slower version of the same feeling: getting attached to a place because of what it cost to keep it, then finding out whether the next generation can hold on to it.

Does that still sound like a survival game to you, or does pulling the camera back this far turn it into something else?

I learned this while researching Salt and Soil (it's my solo-dev game about American Frontier).

John Rolfe’s tobacco became Virginia’s first profitable export. The crop was so attractive that Deputy Governor Thomas Dale initially limited tobacco cultivation because he feared the colonists would neglect basic survival needs. According to the National Park Service, by 1617 people were planting tobacco even in the streets of Jamestown.

That is basically the situation I ended up with in this run.

My family has a Tobacco Plot and three bales ready for market, but food is projected to fall by 10 next year. One bale sells in Jamestown for 7. Food costs 5.

So the profitable crop is also creating the problem it pays to solve: grow tobacco, sell it, buy food, and hope the labor diverted from subsistence was worth it.

I’m making Salt and Soil, a turn-based colony sim about one family living through the changing American frontier from 1609 to 1900.

Would you double down on tobacco, or move the family’s labor back to food?

Steam page: Salt and Soil.

https://wizzard-rick.itch.io/cyber-cowboy — free, runs in the browser, no install.

Backstory: this started as a physical card game we run at live-action roleplay events — netrunning as a two-player asymmetric card duel, one player the deck, one player the server. It works at a table with people. It does not work when you want to play at 2am on a Tuesday.

Then Apple dropped the Neuromancer teaser at Comic-Con last week and I spent a weekend rereading the book instead of sleeping, and decided to build the single-player version I'd been putting off for two years.

What it actually is: you break into a server one contract at a time. Three channels, two actions a tick, a trace counter that only goes one way. Take a port, hold it two checks in a row, and the route to the data opens.

The part I care about: the loot is documents you read. When you work a LOGS or FILES node you don't tick a checkbox, you get a page — an access journal, a shift handover with a timestamp four minutes off, a camera transcript of a woman opening an empty mailbox at 3am. And about half the programs in the shop only become buyable once you've read the page that mentions them. The city writes everything down and nobody reads it; being the one who does is the progression system.

The story that came out of that is less "corp conspiracy" and more "nobody is driving." A service account has been signing lease renewals on behalf of dead tenants since 2081 because six exhausted clerks needed a stopgap at four in the morning and nobody ever came back to close it. Four chapters later you find out what it's actually been holding, and the finale is the one board in the game where taking ports is how you lose.

Bits and pieces: 9 authored chapters across two sequences, ~30 programs, four cyberdeck chassis with modules, procedurally generated contracts across twelve very different servers (a housing registry, a braindance studio, an idol agency, a prison that pays sentences in compute time), a 74-entry codex, two forks with no correct answer. Godot 4.6. Russian and English.

It's rough in places and I'd rather hear that than not. Specifically: is the board readable in the first thirty seconds, and do the documents earn the tick they cost you?

Salt and Soil starts in 1609 with one family and an almost empty patch of land.

You build shelter, store food, raise livestock and gradually turn the place into a working homestead. The unusual part is that the person you start with won’t live to see the end of the run.

They grow old and die. One of their children takes over.

The buildings stay. So do the land, livestock, debts, family relationships and any bad decisions that have since become permanent infrastructure.

The run continues this way through several generations, all the way to 1900. I’m trying to make the base feel less like a layout you perfect and more like a place that each generation inherits, lives with and changes.

For people who play long base-building runs: would losing the original founder make you more attached to the settlement, or would you just want them back?

I’m Roman, the solo developer. I’m planning to open a public Steam Playtest soon, although it isn’t enabled yet.

The game can be wishlisted here: https://store.steampowered.com/app/4551060/Salt_and_Soil_A_Frontier_Family_Sim/

Last week I posted here about Salt and Soil, the game I’m making about one frontier family living from 1609 to 1900. This time I wanted to show more of the actual building system.

There are currently 140 buildings in the tech tree. I may have got slightly carried away.

Every family starts with the same basic needs: shelter, food storage, repairs, roads, record-keeping and safety. From there, the homestead can move in seven different directions: company trade, fur trading, cash crops, timber, livestock, roadside services or mining.

It isn’t one static tree for the whole run. The available buildings change across eight historical eras. Fur trading eventually declines, mining appears later, and railways open up different kinds of trade and industry.

A single family isn’t expected to unlock everything. Later generations inherit what their parents built, then have to decide whether to continue in the same direction or change course.

A small bit of news for this sub: I’m planning to open a public Steam Playtest soon. I haven’t announced that anywhere else yet. It isn’t enabled right now because I’m still getting the build ready, but the plan is to make it open rather than invite-only.

The game can be wishlisted on Steam

If this were your family, where would you start: timber, cattle, mining, fur trading, or an inn for people heading west?

A small Wizzard Tower devlog, and also an introduction, since most people here probably haven’t heard of it before. I’m the person making the game, just to get that out of the way.

I’m currently putting together the fifth playtest version and have started another full campaign run.

I also got impatient, printed all 200-plus pages in their fairly terrible draft layout, and hand-bound the whole thing. I wanted to find out what it’s actually like to play from a real book instead of a PDF. How easy is it to jump between the combat rules, enemy profiles and some obscure injury table? Where do I keep losing my place? How many bookmarks does it take before the book starts looking like an angry paper porcupine?

So, what is Wizzard Tower?

It’s a miniature-agnostic solo campaign wargame. You start with a wizard, a rather poor tower and something that can generously be called a retinue.

From there, you improve your mage and followers, add new rooms to the tower, make friends or enemies among the local factions, hunt for grimoires and prepare to face the campaign’s Big Bad.

There are currently 100 spells across five schools of magic. Magic is powerful, unreliable and dangerous. A good cast can turn a battle around. A bad one can fail at exactly the wrong moment, or leave you with a problem worse than the one you were trying to solve.

The game is deliberately very random. It uses lots of recurring rolls on nested tables. One table sends you to another, which adds a complication, which leads to another roll for the consequences. A fairly ordinary campaign turn can slowly turn into a small disaster that somehow makes perfect sense by the end.

The tables take the place of a GM and an opponent. Enemies use simple behaviour routines on the battlefield, so you don’t have to play chess against yourself while pretending you don’t know the other side’s plan.

You can use whatever fantasy miniatures are already sitting on your shelf, and the game only uses d10s. There are no hit points. Fighters become shaken, exposed and defeated.

The battles themselves aren’t really the main point, though. What matters to me is what happens between them, and what each battle leaves behind.

A failed raid might come back several turns later as a siege. A fighter you saved might gradually become a veteran. A grimoire stolen in one battle might contain the spell that saves the tower in another. Injuries, losses, loot and bad decisions don’t disappear when the miniatures go back on the shelf.

A campaign takes somewhere between 6 and 20 turns, with each turn lasting around half an hour. You can play through one over a few busy evenings, or leave the tower on a shelf and come back to it over several months.

The thinking between sessions is part of the game too. What should I build next? Which spell is worth learning? Do I send the injured veteran on another mission? How am I going to pay this collection of strange people?

You can also finally build a wizard’s tower from a Pringles tube, add new rooms as the campaign progresses, and then defend it from an actual siege. Honestly, that may be what the entire project was secretly about.

The setting is grim, but not hopeless. Thousands of years ago, alien molluscs came to this world. They hide inside suits of knightly armour, control much of the human nobility, and have been slowly remaking the land to suit themselves ever since. They caused the ancient magical catastrophe and released the miasmas that still poison entire regions.

Somewhere in the middle of all this stand the wizards’ towers. They aren’t shining citadels. They’re stubborn little pockets of order that have to be built, supplied and defended. The world is openly hostile, but it’s still worth trying to make a home in it.

The campaigns are the main reason the book has grown so much. At first they were simple frameworks connecting a series of battles. Now each one has become its own way of telling a story and changes the game a little. I want different campaigns to have their own pace, objectives and problems, rather than just swapping one enemy table for another.

The main inspirations are Five Leagues from the Borderlands, X-COM and Battle Brothers.

The last photo shows the much smaller version I made for a game jam last winter. Back then the book was a third of its current size, but it already had a nice cover and some fun temporary AI-generated illustrations inspired by old OSR rulebooks.

Since then, the rules have grown enormously and the entire visual design is being replaced. An illustrator whose work I really like has recently joined the project, so the finished book won’t contain any AI-generated art.

A couple of practical notes:

• “Wizzard” with two z’s is deliberate.
• The current playtest version is only available in Russian. I want to stabilise the rules before starting an English translation. Otherwise the translation would be chasing a game that keeps changing underneath it.
• If you read Russian and would like to join the playtest, feel free to message me. And a huge thank you to everyone who’s already helping me test this enormous thing.

Hi, I’m the solo developer of Salt and Soil.

Gameplay trailer: https://www.youtube.com/watch?v=oan28f_4P-o
Steam: https://store.steampowered.com/app/4551060/Salt_and_Soil_A_Frontier_Family_Sim/

Most historical strategy games place you above the map. You control a country, start wars and redraw borders.

Salt and Soil approaches history from the opposite direction. You guide one ordinary family living through nearly three centuries of North American colonization, from 1609 to 1900.

Major historical events happen without your permission. Wars begin, borders move, settlements and trade routes appear, and relationships between different communities change. You cannot rewrite those events. You have to deal with whatever eventually reaches your home.

Each turn represents one year. You manage food, materials, money, livestock and scarce family labor; build and improve the homestead; trade with nearby communities; and decide which risks the household can afford.

Family members marry, have children, argue, grow old, leave and die. There is no permanent protagonist. When the head of the household is gone, another generation inherits the ranch together with its buildings, debts, relationships, reputation and unfinished problems.

At the end of every year, the household gathers for a Family Council shaped by what actually happened during that campaign. Decisions made there can remain part of the family’s history for decades.

The game is currently in active testing and is planned for Windows and macOS. The release date has not been announced yet.

If the premise sounds interesting, wishlisting Salt and Soil on Steam would help me enormously as a solo developer.