The Slow Erosion of Value

In my experience, this shift didn’t happen overnight. It’s been more like a slow drip — a constant lowering of the barrier to entry for users, paired with rising expectations for what should be freely available. Audiences have grown to want more for less, and that change has reshaped how we, as developers, build and deliver software.

Back in the 2000s, we used to sell a cross-section of Windows applications. These were typically released as shareware — fully functional, but with some kind of limitation. Maybe it was time-limited, or perhaps certain features were locked behind a registration key. If the user found value in the software, they could unlock the full version. Simple. Fair.

At the time, a whole ecosystem of download sites existed to support this model. They acted as distribution hubs, allowing users to discover new software, try it out, and purchase it if it met their needs. It wasn’t perfect, but it worked. There was a clear value exchange: software solved a problem, and users paid for that solution.

This wasn’t about open source or a “free software” movement — it was about sustainable software distribution.

But then something started to change. Bit by bit, developers began offering more generous free editions, trimming fewer features, removing time limits, or even offering entire lite versions for free. Some split their products into different strands entirely — one version for casual users with basic needs, and a paid version for power users or professionals.

Some argue piracy pushed developers toward these new models — forced them to adapt. Instead of relying purely on software sales, revenue started shifting to alternative strategies: paid support, in-app advertising, bundled services, or, in more cynical cases, harvesting user data. Whatever the motivation, the result was the same: the perceived value of software continued to drop, and expectations shifted with it.

The Great Vanishing Act: Social Media and Search Engines

While developers were adjusting to the “race to free,” another tectonic shift was quietly unfolding: the collapse of discovery.

There was a time when building something useful and publishing it online gave you a decent chance of being seen. Early search engines, though far from perfect, prioritized relevance and freshness. Social media promised a new kind of reach — direct connection with users, fans, customers. For a while, it worked. A tweet, a blog post, a forum thread — these could ripple outward and find real people who cared.

That era is over.

Today, social platforms have devolved into throttled silos. You can have thousands of followers and still struggle to get a dozen views on a post unless you play the algorithm game — or pay to “boost” visibility. Engagement is driven not by merit, but by outrage, meme-ability, or timing. Even “communities” feel less like towns and more like haunted malls — full of recycled content, echo chambers, or silent scroll-bys.

Search engines aren’t any better. Try looking up a specific kind of software or development tool today, and you’re greeted by a wall of SEO-optimized garbage: faceless blog farms, AI-generated summaries, affiliate-heavy “Top 10” lists that have no real insight — just endless noise. Organic discovery has been buried under monetization and manipulation.

The irony? We’ve never had more content — more apps, more tools, more creativity online — yet reaching an actual human being with something honest and useful is harder than ever.

This has huge consequences for developers. Building the software is only half the battle now. You also need to master the dark art of content marketing, navigate shifting social trends, stay in the good graces of opaque algorithms, and somehow still find the energy to keep your codebase from collapsing under constant platform churn.

It’s exhausting. And it’s no wonder so many indie developers quietly disappear — not from lack of talent, but from a lack of reach.

The Distorted Value of Software

Software used to be seen as a product — a tool someone built, tested, and sold, like any crafted item. There was a clear sense of value: a developer solves a problem, and the user pays for that solution. Simple economics. But somewhere along the line, that model fractured. Platforms didn’t just disrupt the way software was distributed — they rewrote the rules of what people think software is worth.

Take mobile apps, for example. The rise of app stores introduced convenience and global reach, but also drove prices into the ground. Suddenly, developers were competing not just with other paid apps, but with free everything. To survive, many had to shift to freemium models — giving away core features and gating the rest. But the damage was already done: users were being trained to expect entire applications for nothing.

That expectation didn’t stay confined to mobile. Over time, it spread across platforms. “Free” became the standard — not because it made sense, but because the platforms that mediate access to users profit from volume, not value. Apple, Google, Meta, and others don’t care what your software costs — they care about engagement, data, and ad revenue. The more things people download and interact with, the better for them. Whether a developer gets paid is incidental.

This distortion leads to absurd outcomes. A user might spend $6 on a coffee without thinking twice, but scoff at a $3 app that took six months to build. They'll binge hours of free software reviews on YouTube — funded by ads — but balk at a one-time purchase that supports a real creator directly. In this environment, even a fair price feels like a violation of some unwritten rule: “It’s digital — why should I pay?”

And this is where the rabbit hole goes deepest: users have internalized the platform’s values. If it’s not free, it’s suspect. If it’s not viral, it’s invisible. The only way to “win” is to give away your work, and hope to monetize later — maybe through donations, maybe through volume, maybe through some yet-to-be-invented hustle.

But real software — thoughtful, original, and well-supported — takes time. It takes energy. And when its value is constantly questioned, or ignored altogether, the system doesn’t just fail developers — it fails users too. Because eventually, good software stops getting made. Or worse: it only gets made by companies whose real product is the user, not the tool.

Where Does This Leave Developers Now?

For developers — especially independents — the ground has never felt more unstable. The tools have improved, the platforms have multiplied, and the audience has grown — and yet, it’s never been harder to make a living from software.

The modern indie dev wears every hat: builder, tester, designer, marketer, customer support, social media presence, and content creator — all while contending with users who expect polished, cross-platform functionality for free. You can put in six months building something genuinely useful, only for it to be dismissed in five seconds because it’s not free, or not popular, or not ranking on some algorithmic feed.

Worse still, the platforms themselves offer no consistency. One week your app or tool goes semi-viral and you think, Maybe this is it. The next week, your reach vanishes. No explanation. No recourse. Just silence.

This is the new normal: developing in a vacuum, with no guarantee that effort equals outcome.

Some developers adapt by chasing virality. Others go niche, hoping to find a small but loyal user base. A few still cling to the old model of pay-once licensing, trying to educate users about the value behind what they’re getting. But increasingly, developers are being nudged — or forced — toward models that don’t prioritize craft or utility, but engagement: ads, subscriptions, bundles, data collection, or selling their soul to platform-specific ecosystems.

That’s not sustainability. That’s survival.

It’s a kind of slow-burn burnout that creeps in — not because the work is hard (it always was), but because the reward structure no longer makes sense. You create something valuable, but the market’s mechanisms for recognizing that value are broken. And when developers can’t even get feedback — can’t even get seen — the silence becomes louder than criticism.

Some quit. Some pivot. Some keep going, out of habit or hope. But nobody can honestly say the system is working for the people who build things anymore.

What Now?

I don’t know what the answer is — but it’s definitely not more of the same.

The landscape we once knew has eroded, almost imperceptibly, under our feet. Choice has been quietly stripped away. The transition from independent websites to the social media monoculture wasn’t just about convenience — it was a wholesale loss of autonomy. The old ecosystem — messy, diverse, and full of personality — gave way to a handful of centralized feeds where everything looks and feels the same.

And that’s the real tragedy: today, many developer sites aren’t homes anymore — they’re just link portals. Buttons to app stores. Embeds from Discord servers. A “community” reduced to comment threads in algorithm-driven silos. We used to build hubs that welcomed users in, that told a story, that taught people what the software was and who it was for. Now? You’re just funnelling people toward a store page and hoping they don’t bounce.

As more of those independent sites disappear, so does our collective presence. The ripple effect kills discoverability. Search engines become even more hollow — fewer developer-run pages, fewer backlinks, less context, less authority. Everyone gets drowned in noise, and only the biggest platforms benefit.

There is one thing we can do: keep our homes alive.

Keep your independent site up. Keep publishing. Keep documenting your software, your thought process, your updates — even if only a handful of people read it. Link to other indie devs you respect. Drive traffic toward them. Treat your site not just as a billboard, but as a hub — something living and worth revisiting.

It might not change the tide overnight. But every site that stays online is one more light in the dark — and if we’re going to rebuild anything, that’s where it starts.

💬 Join the Conversation

Have you noticed the shift in how people value software?

Are we losing more than just revenue in this age of “free”? I’d love to hear your thoughts.

Leave a comment below or reach out on X.com — let’s talk about where indie software goes from here.

If this article resonated with you, consider subscribing or exploring more posts on the changing landscape of software development and digital culture.

From Polygons to Photorealism: The Evolution—and Plateau—of 3D Game Graphics

The Era of Clever Constraints

In the early days of 3D gaming, hardware limitations forced developers to be clever. The visuals that defined an era—whether low-poly models, billboarding sprites, or pre-rendered backdrops—weren't just stylistic choices, but practical necessities. Every polygon had a cost. Every lighting trick was a compromise. But out of those limitations grew a golden age of innovation.

Turning Limitations Into Innovation

Take a look at games like Quake, Tomb Raider, or Final Fantasy VII. Each used the best of what the hardware of the time could handle, and did so in strikingly different ways. Quake leaned into full 3D environments with software-based lighting and gritty realism. Tomb Raider featured angular characters and blocky worlds that became iconic not despite their limitations, but because of them. Final Fantasy VII sidestepped real-time rendering entirely for much of its world, instead presenting lush pre-rendered scenes and letting players move 3D models across them. These games didn’t just work around limitations—they turned them into defining characteristics.

Leaps in Generational Power

With each new generation of graphics cards and consoles, we saw significant leaps. The move from software to hardware acceleration, the introduction of hardware T&L (Transform and Lighting), then programmable shaders—each of these brought clear visual benefits. By the early 2000s, games like Half-Life 2 and Doom 3 pushed lighting, animation, and physics into new territory. Visuals didn't just get better—they evolved.

The Plateau of Realism

But something changed in the last decade. As we neared photorealism, the rate of visual evolution began to slow. High-fidelity rendering techniques—global illumination, subsurface scattering, ray tracing—deliver spectacular results, but they come with steep performance costs. The problem is, these improvements aren't always obvious to the average player. When a scene already looks real, doubling the polygon count or pushing texture resolution to 8K yields diminishing returns. What once felt like huge jumps between generations now feels more like refinements.

Style Over Specs

Games like The Last of Us Part II, Red Dead Redemption 2, and Cyberpunk 2077 have reached a level where stylization and direction matter more than sheer rendering muscle. Once you're able to render a believable scene, it becomes less about adding detail and more about how you use the tools. It’s a creative turning point: technology is no longer the main limiting factor. Imagination is.

A Full-Circle Moment

Interestingly, this full-circle moment mirrors the past. We're seeing renewed interest in stylized graphics, from indie darlings like Hades and Tunic to AAA experiments like Hi-Fi Rush. Developers are embracing non-photorealistic styles not because they have to, but because they can. Limitations no longer dictate style—they inform it. And in doing so, we're seeing a broader range of visual expression than ever before.

Looking Ahead

As 3D hardware continues to improve, we may well see new breakthroughs. But the era of obvious, generational leaps in visuals is behind us. The future lies not in chasing realism, but in harnessing the freedom to create something uniquely beautiful, meaningful, and memorable.

🎮 Join the Discussion

What do you think—have we reached the peak of 3D visual evolution, or is there still another revolution waiting to happen?

Share your thoughts in the comments below or connect with me on X.com

If you enjoyed this article, consider subscribing or checking out some of my other posts on the evolution of game development and technology.

When people talk about the first true 3D video games, titles like Quake or Super Mario 64 often take the spotlight. These games marked a significant leap forward with fully texture-mapped environments, perspective-correct projection, and dynamic camera control. But this view tends to overshadow a rich decade of 3D experimentation on much less capable machines. To truly appreciate the origins of 3D gaming, we need to roll back to the 8-bit and 16-bit eras, where pushing polygons was a brutal, low-level grind, limited by memory, math, and raw CPU cycles.

The 8-bit Foundations

Writing a 3D game on an 8-bit system like the Commodore 64 or ZX Spectrum was a challenge of epic proportions. These systems had CPUs like the 6510 or Z80, typically clocked under 2 MHz. RAM was sparse—often 48K or less—and there were no floating-point units or hardware multipliers. Everything had to be done in software, often with 8-bit math stretched to fake 16- or 32-bit results.

Take a 16-bit multiplication on a 6510:

; Multiply 8-bit A by 8-bit B, result in 16-bit
clc
ldx #8        ; loop for 8 bits
lda #0         ; clear result low
sta resultLo
sta resultHi

loop:
lsr B          ; shift right B, carry holds current bit
bcc skipAdd    ; if bit not set, skip add
clc
lda resultLo
adc A
sta resultLo
bcc noCarry
inc resultHi
noCarry:
skipAdd:
asl A          ; shift A left for next bit
rol resultHi
rol resultLo

inx
cpx #8
bne loop

This was the sort of routine you'd write just to multiply two numbers. Think about trying to do vector math, matrix transformations, or projection in real time with this.

Yet somehow, developers managed. Games like Elite delivered wireframe 3D on systems with no right to be doing 3D at all. How? Precomputed tables, integer-only math, and incredibly tight assembly code.

The 16-bit Leap

The 16-bit era (Amiga, Atari ST, early PCs) brought huge improvements: faster CPUs (Motorola 68000, x86), more RAM, and hardware that made color and resolution viable for real-time rendering.

But even then, rendering filled polygons was tough. A scene with more than a handful of polygons meant serious compromises. Occlusion was mostly just backface culling and manual z-sorting. Overdraw was rampant. Color palettes were limited.

The 68000, for example, was a joy compared to 8-bit CPUs—32-bit registers, hardware multiply, and full stack access. But it still had no floating-point unit, so most games still ran on fixed-point math.

3D Rotations

Rotating a point in 3D requires matrix multiplication. In floating point, it’s simple. On an 8- or 16-bit system? You’re manually calculating each axis:

// Rotate point (x, y, z) around Y axis
cosA = cos(angle)
sinA = sin(angle)

x' = x * cosA + z * sinA
z' = -x * sinA + z * cosA
y' = y

On a machine with no hardware multiply or sin/cos functions, these had to be:

for y from top to bottom:
    leftX = interpolateEdge1(y)
    rightX = interpolateEdge2(y)
    drawHorizontalLine(leftX, rightX, y)

screen_x = (x / z) * focal_length + screen_center_x
screen_y = (y / z) * focal_length + screen_center_y

invZ = reciprocal(z)  ; precomputed
screen_x = (x * invZ) >> shift

for each pixel in scanline:
    u = uStart + (du * x)
    v = vStart + (dv * x)
    color = texture[u >> 8][v >> 8]
    framebuffer[x][y] = color

u = (u/z), v = (v/z) — per pixel!

for each column:
    ray = shoot_ray(player_pos, angle)
    distance = find_wall_hit(ray)
    wall_height = screen_height / distance
    draw_column(column, wall_texture, wall_height)