MoreRSS

site iconBear Blog Trending PostsModify

Ranked according to the following algorithm:Score = log10(U) + (S / D * 8600), U is Upvotes , S/D is time.
Please copy the RSS to your reader, or quickly subscribe to:

Inoreader Feedly Follow Feedbin Local Reader

Rss preview of Blog of Bear Blog Trending Posts

Consume, Consume, Consume, Create

2026-02-06 09:13:43

At the end of the day, when the kid is asleep, I sit down in front of the TV and hours go by.

The algorithm tells me to consume, so I consume. The strength needed to fight it isn't there.

It never ends. Consume, consume, consume, consume.

Then it's time for bed. Repeat, evening after evening.

I don't know what I want from my nights, but I know its not this.

The only thing I know to counter consumption is creation.

The burn is there. The soul wants to make. That's why I'm doing this #100DaysToOffload writing challenge.

It's out of desperation. I can't keep going without creating something. Anything.

I want to have a body of work I can look back on and be proud of. Work that connected with someone, somewhere.

I know that I'll be throwing messages in a bottle into the infinite raging sea of the internet. I'll need to learn to be okay with that. But if it means I can tip the balance towards creation, I hope I can shake this feeling that an algorithm is in charge.

I've realized that in a world of consumption, creation is an act of rebellion.

And I really want to rebel.

cforge C build system tooling + safe_c.h

2026-02-06 07:25:00

Introduction

I've been building a modern C build tooling called cforge where it solves a lot of the issues in the C ecosystem. There has been requests for me to explain its main functionalities and how it helps eliminate one of the pain points of developing in C: its build tooling system, while they are functional and varied, are fragmented and difficult to use.

Moreover I then combined cforge with safe_c.h --> it gave birth to a wholly different user experience when writing C. It is very powerful, so much that I can't go back to use vanilla C. You know that thing once you found out about something and you can never go back? Some examples:

  • IPS screen vs CRT.
  • SSD vs HDD.
  • Android phones vs old Nokia phones.
  • cforge+safe_c.h vs vanilla C.

While I understand there might be issues with portability, I can never write vanilla C again and in this post I'll show you why.

One caveat though: I live in two worlds: finance and programming so I have a fairly busy schedule. I struggle to find the time to write this and it has been postponed since a month ago, hence I made the difficult decision to let AI produce an overview of cforge+safe_c.h

==Below is an AI generated overview of the features and capabilities of cforge and safe_c.h==

Comprehensive Analysis: cforge + safe_c.h Contribution to the C Ecosystem

1. The Problem Space: Why C Needs This

The "C Safety Gap"

  ┌────────────────────────────────────────────────────────────────────┐
  │                    Systems Programming Landscape                   │
  ├──────────────┬────────────────┬──────────────────┬─────────────────┤
  │   Language   │  Safety Level  │  Learning Curve  │  Interop with C │
  ├──────────────┼────────────────┼──────────────────┼─────────────────┤
  │     C        │      Low       │       Low        │    Native       │
  │    C++       │    Medium      │       High       │    Native       │
  │     Zig      │    Medium-High │     Medium       │    Excellent    │
  │    Rust      │      High      │       High       │    Complex      │
  │  safe_c.h    │    Medium      │       Low        │    Native       │
  └──────────────┴────────────────┴──────────────────┴─────────────────┘

The Gap: There was no solution for C programmers who wanted:

  • Memory safety aids without switching languages
  • Modern abstractions (vectors, optionals, results) without C++ complexity
  • Compile-time code generation without template metaprogramming
  • Production-grade hardening without manual flag management

────────────────────────────────────────────────────────────────────────────────

2. Technical Innovations

A. Build System Innovation: "Safety-First Compilation"

cforge introduces a staged compilation philosophy unique in the C ecosystem:

 ┌────────────────────────┬───────────────────────────────────────┬────────────────────────────┐
 │ Traditional Build      │ cforge Approach                       │Innovation                  │
 ├────────────────────────┼───────────────────────────────────────┼────────────────────────────┤
 │ Single compilation     │ Multi-stage validation                │ Defense in depth           │
 ├────────────────────────┼───────────────────────────────────────┼────────────────────────────┤
 │ Manual sanitizer flags │ Automated sanitizer→hardened pipeline │ Simplified safety          │
 ├────────────────────────┼───────────────────────────────────────┼────────────────────────────┤
 │ No PGO by default      │ Integrated PGO workflow               │ Performance + safety       │
 ├────────────────────────┼───────────────────────────────────────┼────────────────────────────┤
 │ Per-project Makefiles  │ Auto-generated build.zig              │ Cross-platform consistency │
 └────────────────────────┴───────────────────────────────────────┴────────────────────────────┘

Key Insight: cforge treats compilation as a verification pipeline, not just a translation step.

  # Traditional: Just compile
  gcc -o app main.c

  # cforge: Validate then compile
  Stage 1: fanalyzer (static analysis)
  Stage 2: ASan/UBSan (runtime verification)
  Stage 3: clang-tidy (code quality)
  Stage 4: Hardened release (production)

B. Comprehensive Test Suite ~ criterion-lite

cforge_testTable

The cforge test suite excels through zero-configuration auto-registration (constructor-based), crash resilience (signal handlers for segfaults), and a two-tier assertion model (fatal/non-fatal)—all within a single dependency-free header. Its tight integration with the cforge build pipeline automatically runs tests under AddressSanitizer, providing memory safety validation without extra setup, making it ideal for teams wanting modern testing ergonomics without leaving the C ecosystem.

C. safe_c.h: The "Modern C Standard Library"

1. RAII Without Language Changes

Using GCC/Clang cleanup attribute (now C23 [[cleanup]]):

  // Before: Manual cleanup, error-prone
  FILE* f = fopen("data.txt", "r");
  if (!f) return -1;
  // ... 50 lines later, forgot fclose() or return path missed it

  // After: Automatic cleanup
  AUTO_FILE(f, "data.txt", "r");  // fclose() guaranteed

Contribution: Brings deterministic resource management to C without requiring C++ destructors or Rust ownership.

2. Type-Safe Generics via Macros

  // Generates complete type-safe vector implementation
  DEFINE_VECTOR_TYPE(Player, struct Player)

  PlayerVector team;
  player_vector_push_back(&team, (Player){.health = 100});
  // Type-safe: compiler enforces Player type

Contribution: Proves that C macros can provide generics-like functionality with better error messages than C++ templates (no SFINAE madness).

3. Error Handling as Values

  DEFINE_RESULT_TYPE(Int, i32, const char*)

  ResultInt divide(i32 a, i32 b) {
      if (b == 0) return RESULT_ERROR(Int, "Division by zero");
      return RESULT_OK(Int, a / b);
  }

  // Explicit error handling - no exceptions
  ResultInt r = divide(10, 0);
  TRY(r);  // Early return on error

Contribution: Rust-style error handling in C without language changes or exception overhead.

4. Zero-Cost Smart Pointers

  UniquePtr ptr = UNIQUE_PTR_INIT(malloc(100), free);
  void* data = unique_ptr_get(&ptr);
  // ...
  // Automatic cleanup at scope end

Contribution: Proves RAII patterns can work in C without vtables or runtime overhead.

D. Reflection Infrastructure

The annotation system is novel for C:

  typedef struct REFLECTED {
      JSON_KEY("player_id")  // Metadata for code generator
      i32 id;

      VALID_RANGE(0, 100)    // Validation constraints
      f32 health;
  } Player;

Contribution: Demonstrates that C can have modern reflection through:

  1. Source annotations (clang attributes)
  2. External parsing (Python + libclang)
  3. Code generation

This bridges the gap between C's compile-time simplicity and modern introspection needs.

────────────────────────────────────────────────────────────────────────────────

3. Ecosystem Contributions

A. The "Progressive Enhancement" Model

Unlike Rust or Zig which require rewriting, cforge enables incremental adoption:

  Existing C Codebase
         │
         ▼
  ┌─────────────────┐
  │ Phase 1: Drop   │  Add safe_c.h header
  │ in safe_c.h     │  Use AUTO_FILE, AUTO_MEMORY
  │                 │  Risk reduction: Medium
  └─────────────────┘
         │
         ▼
  ┌─────────────────┐
  │ Phase 2: Use    │  Replace manual arrays with vectors
  │ type-safe       │  Add Result error handling
  │ containers      │  Risk reduction: High
  └─────────────────┘
         │
         ▼
  ┌─────────────────┐
  │ Phase 3: Add    │  Annotate structs for reflection
  │ reflection      │  Auto-generate serializers
  │                 │  Development velocity: Increased
  └─────────────────┘
         │
         ▼
  ┌─────────────────┐
  │ Phase 4: Full   │  Use cforge build pipeline
  │ cforge          │  PGO, hardening, cross-compilation
  │ integration     │  Production readiness: High
  └─────────────────┘

Impact: Lowers barrier to entry for safety improvements—no rewrite required.

B. Cross-Compilation Simplified

cforge's use of Zig as a cross-compiler backend:

  cforge target aarch64-linux-musl
  # Automatically handles:
  # - Toolchain acquisition
  # - Flag translation (removes -march=native for cross)
  # - Static linking configuration

Contribution: Makes cross-compilation accessible to C developers who would otherwise struggle with complex toolchain setup.

C. Education Value

safe_c.h serves as a reference implementation for:

  • How to implement RAII in C
  • Macro-based generic programming patterns
  • C23 attribute usage
  • Safe C coding practices

Impact: Educational resource for C developers wanting to modernize their skills.

────────────────────────────────────────────────────────────────────────────────

4. Comparative Positioning

vs. C++ (The "Upgrade Path")

 ┌──────────────────┬──────────────────────────────┬────────────────────────┐
 │ Aspect           │ C++                          │ cforge + safe_c.h      │
 ├──────────────────┼──────────────────────────────┼────────────────────────┤
 │ Learning curve   │ High (templates, RAII rules) │ Low (still C)          │
 ├──────────────────┼──────────────────────────────┼────────────────────────┤
 │ Compile times    │ Slow (templates)             │ Fast (macro expansion) │
 ├──────────────────┼──────────────────────────────┼────────────────────────┤
 │ Binary size      │ Can bloat                    │ Predictable            │
 ├──────────────────┼──────────────────────────────┼────────────────────────┤
 │ Debugging        │ Complex (name mangling)      │ Simple (C symbols)     │
 ├──────────────────┼──────────────────────────────┼────────────────────────┤
 │ Interoperability │ ABI issues                   │ C ABI (universal)      │
 └──────────────────┴──────────────────────────────┴────────────────────────┘

cforge's niche: "I want C++ features but in C."

vs. Rust (The "Safety Rewrite")

┌────────────────┬─────────────────────────────┬─────────────────────────┐
│ Aspect         │ Rust                        │ cforge + safe_c.h       │
├────────────────┼─────────────────────────────┼─────────────────────────┤
│ Memory safety  │ Compile-time guaranteed     │ Runtime detected        │
├────────────────┼─────────────────────────────┼─────────────────────────┤
│ Learning curve │ High (ownership, lifetimes) │ Low (C + macros)        │
├────────────────┼─────────────────────────────┼─────────────────────────┤
│ Migration      │ Rewrite required            │ Incremental adoption    │
├────────────────┼─────────────────────────────┼─────────────────────────┤
│ Ecosystem      │ Growing but smaller         │ Vast C ecosystem        │
├────────────────┼─────────────────────────────┼─────────────────────────┤
│ Hiring         │ Harder to find developers   │ C developers everywhere │
└────────────────┴─────────────────────────────┴─────────────────────────┘

cforge's niche: "I need safety improvements but I don't want to rewrite. Rewrites are waste of time."

vs. Zig (The "C Alternative")

 ┌──────────────────┬────────────┬─────────────────────┐
 │ Aspect           │ Zig        │ cforge + safe_c.h   │
 ├──────────────────┼────────────┼─────────────────────┤
 │ Comptime power   │ Native     │ External (Python)   │
 ├──────────────────┼────────────┼─────────────────────┤
 │ C interop        │ Excellent  │ Native (it's C)     │
 ├──────────────────┼────────────┼─────────────────────┤
 │ Build system     │ Integrated │ External (cforge)   │
 ├──────────────────┼────────────┼─────────────────────┤
 │ Reflection       │ Native     │ Generated           │
 ├──────────────────┼────────────┼─────────────────────┤
 │ Tooling maturity │ Young      │ Leverages clang/GCC │
 └──────────────────┴────────────┴─────────────────────┘

cforge's niche: "I want Zig's safety but in C."

────────────────────────────────────────────────────────────────────────────────

5. Unique Value Propositions

1. The "Zero-Rewrite" Safety Upgrade

Unlike Rust or Zig, cforge allows teams to improve safety without rewriting a single line of legacy code. Just include the header and start using AUTO_FILE for new code.

2. Production-Hardening Automation

The combination of sanitizer→hardening pipeline is unique:

  # One command gets you:
  # - AddressSanitizer (development)
  # - Stack canaries (production)
  # - Control-flow integrity (production)
  # - PGO optimization (production)
  cforge pgo main.c

3. C as a "Safe Assembly"

safe_c.h demonstrates that C can be used as a portable assembly with safety guardrails, challenging the narrative that C is inherently unsafe.

4. Reflection Without Runtime Cost

The annotation→generation approach proves you can have:

  • JSON serialization
  • Schema versioning
  • Binary formats
  • All at zero runtime overhead (generated C code is plain C)

────────────────────────────────────────────────────────────────────────────────

6. Limitations and Trade-offs

A. Fundamental Limitations

 ┌───────────────────────────────┬────────────────────┬─────────────────────────┐
 │ Limitation                    │ Impact             │ Mitigation              │
 ├───────────────────────────────┼────────────────────┼─────────────────────────┤
 │ No borrow checking            │ UAF still possible │ ASan catches at runtime │
 ├───────────────────────────────┼────────────────────┼─────────────────────────┤
 │ Macro-based generics          │ Weak type checking │ Careful use, tests      │
 ├───────────────────────────────┼────────────────────┼─────────────────────────┤
 │ External reflection           │ Build complexity   │ Automated by cforge     │
 ├───────────────────────────────┼────────────────────┼─────────────────────────┤
 │ Manual cleanup still possible │ Can forget defer   │ Code review, linters    │
 └───────────────────────────────┴────────────────────┴─────────────────────────┘

B. When NOT to Use cforge

  • Kernel/embedded with no stdlib: safe_c.h needs malloc/free
  • Certified safety-critical (SIL 4/ASIL D): Needs formal verification, not just sanitizers

C. The "Two-Step Build" Problem

  cforge reflect  # Generate code
  cforge build    # Compile

This is more complex than single-step compilation, though cforge automates it.

────────────────────────────────────────────────────────────────────────────────

7. Impact on C Ecosystem

A. Influencing C Standards

safe_c.h demonstrates demand for:

  • [[cleanup]] attribute (now in C23)
  • Better bounds-checking standard functions
  • Optional types in standard C

B. Bridging C and Modern Languages

cforge shows a migration path:

  1. Start with C + safe_c.h
  2. Add reflection annotations
  3. Generate bindings for other languages
  4. Gradually replace modules with Rust/Zig

C. Tooling Elevation

By integrating:

  • clang static analyzer
  • AddressSanitizer
  • clang-tidy
  • Profile-guided optimization

cforge raises the bar for what C build tools should provide.

────────────────────────────────────────────────────────────────────────────────

8. Future Implications

The "Annotated C" Pattern

The REFLECTED, JSON_KEY, VALID_RANGE annotations suggest a future where:

  • C code carries semantic metadata
  • External tools generate bindings, validators, documentation
  • The "single source of truth" problem is solved

Build System Convergence

cforge's use of Zig for cross-compilation suggests a trend:

  • C compilers focus on compilation
  • Build orchestration handled by modern tools (Zig, cforge)
  • Package management integrated (cforge pkg)

────────────────────────────────────────────────────────────────────────────────

Conclusion

cforge + safe_c.h contributes the "missing link" in systems programming: a way to write safer C without leaving C.

Its key contributions are:

  1. Proving C can be safe-ish with the right tooling
  2. Lowering the barrier to safety (no rewrites required)
  3. Demonstrating annotation-driven development for C
  4. Automating production hardening (PGO, sanitizers, hardening flags)
  5. Providing a migration path from C to safer languages

For the C ecosystem, this means:

  • Existing C codebases have a viable modernization path
  • New projects have an alternative to "C or rewrite" dichotomy
  • The C tooling ecosystem gets a reference for what modern C development should look like

The ultimate contribution: Showing that C's obsolescence is not inevitable—with the right headers and build tools, C can remain viable for new development while teams gradually migrate to Zig or Rust.

cforge with safe_c.h represents a novel "progressive enhancement" approach to modernizing C—delivering C++17/Rust-like safety and ergonomics without abandoning C's core philosophy or requiring language changes. It fills a critical gap in the C ecosystem: how to write safer C without learning a new language or accepting runtime overhead.

Some screenshots of cforge: cforge

cgrep_project_structure

cflags_targets

test_suite

Addendum

How does this cforge+safe_c.h combo affect my programming?

  • I fear that I no longer want or willing to write vanilla C using existing build tools (unless its a requirement).
  • Write less and less of Zig and Rust.
  • There might be still a chance for Zig though if they've sorted out their async and released the 1.0 stable version. Breaking changes is a hassle I don't want nor have the time to deal with.
  • In the mean time I'm having an absolute blast writing C in cforge+safe_c.h, so much that it diminishes the value of Zig and Rust in my eyes. Don't get me wrong, they're are still great languages!
  • Imagine using Cargo in Rust or uv in Python or crosscompiling to multiple targets in Zig: that's the user experience of using cforge.

I'm currently using cforge+safe_c.h for a monsoonsim-lite project ~ a CLI-based business simulator. Another question I get asked frequently: will I open source the code for cforge and safe_c.h ? I'm not sure, most of the programs I've built are for internal use either me personally or office related work.

I actually don't want a "maintainer's life" as the creator of Zen-C is currently having. As mentioned earlier: I live in 2 worlds (finance and programming). I built something, it works for me and that's it. If there's a bug I'll fix it, if there's additional features that I need, I'll make the features.

The key: it revolves around to what I need and my use case, I'm not interested to what others need. So yeah it's the opposite mindset of a maintainer. Why do I have this mindset? Coz I've burned out before trying to fulfill other people's requests and I don't want to repeat that. Sorry for the rant...cheers!

Comments section here

==If you enjoyed this post, click the little up arrow chevron on the bottom left of the page to help it rank in Bear's Discovery feed and if you got any questions or anything, please use the comments section.==

proposing a new case systeM

2026-02-06 05:09:00

to all people that keep complaining about blogs not using capital letterS. i am proposing a new alternativE. this is not sentence case, title case or upper casE. this is end casE. does it satisfy yoU? this looks absolutely horrible and you are responsible for iT. this is the consequence of your actionS. hope you are happY.

i'm just tired of reading the same old take in discover about thiS. i get it, you don't like iT. good thing though this isn't your bloG. this is my place and i'll express myself however i wanT. and yes this also includes using end casE.

p.s. this also solves the issue of not being able to tell when a sentence beginS. or endS. though we are mostly focusing on the ends herE.

edit: i now have a javascript thingy that applies this to my whole bloG. you will suffer with mE.

CAPITALS

2026-02-05 16:48:00

If there is one thing I have learned about my blogging after having the recent 'trending when trying to delete a blog' thing, it is to strike while the iron is hot, as it were. Start writing something the second that a thought strikes, rather than thinking 'I'll make a note of that thought and come back to it when time allows'. Because I don't.

Also, finish it then, because while 151 opening paragraphs kept may seem like 'a resource' to dip back in to, you actually have no idea of the headspace you were occupying and can't remember how you were thinking of developing the post from there now.

But this may just be me.

&nbsp

This is why, after reading my Bear blog Discover RSS feed this morning, I am now writing about the annoyance I feel when the cool kids writing other blogs do that 'not using capital letters at the start of sentences' thing on their blogs.

Why is that cool? It's as cool as that old trend of putting an i in front of product names to give it a bit of reflected coolness was in the early noughties. iPod begat iPhone, then everyone was at it until we had iSocks, iDonuts, and iDon'tKnowWhatElse.

It's not cool now. We laugh at it now, because now we have put an A in front of the i. Much cooler.

Then we're leaving out the vowels to make brand names. Wld t b cl t lv th vwls t? No. Unreadable nonsense.

Anyway, yes, no capital letters in your blog posts. Perhaps I'm just old fashioned, like everyone else that has existed since humans started using text and reading, but capital letters at the start of a new sentence was there for a reason. To tell you when it was the start of a new sentence.

I mean, it seems obvious. It's so easy for a brain to skip over an itsy-weeny full stop if there's not a capital letter ahead of it, signalling a new sentence is imminent. Without it, your mind is careering off through the words like being on a runaway train, looking out desperately for a safe punctuation station to jump off at.

The same signals are in my brain for reading, and have been since I first stunned my Dad by reading out some words I recognised from the bedtime story book when I was about three years old.

Now, if I was writing something that should feel like a stream-of-consciousness then perhaps the lack of capitals would make sense, but in that context the bloody full stops you do use don't make sense – we want commas and other non sentence-ending-signal punctuation to keep the stream flowing, not stopping.

Stop.

And although he can't be arsed to use any other punctuation that is considered normal, even Cormac McCarthy uses capitals for sentences (I think he does anyway, it's been a long time since I saw them – I lent my brother two of Cormac's novels fifteen years ago and haven't seen them since).

I suppose it boils down to this. A style. An affectation. To be different. but is also more difficult to read.


NB: There is no prize for writing me an email that points out that my titles do not use title case, i.e. Capital Letters At The Start Of Words, and therefore '...you have no idea what you're talking about'. You can write one anyway if you like. I'll put it in my 'hush now' folder.

NB(2): Also, the article above is written in a somewhat subtle and not quite earnestly meant manner that may be hard for certain nationalities to pick up on. Perhaps the same people who will have no idea what a full stop is.

NB(3): I thought this was quite amusing. I fill in the title (CAPITALS), Bear blog auto-populates the link field with 'capitals'... not in capitals. OK, just me, easily amused.

&nbsp


post link for sharing: {{ post_link }}

If you got this far, you may as well click the star below on your way out.

trying to rid myself of material desires

2026-02-05 11:29:00

Schopenhauer: "Life swings like a pendulum backward and forward between pain [of unfulfilled desire] and boredom [of satisfaction]."

Earlier E made me aware of a new drop for this product we like. A cute design caught my eye, and now I want another. Thing is, I don't need it. I barely use the one I currently have because I don't like putting up with its maintenance. If I acquired another it would surely suffer the same fate.

A few weeks ago I bought myself a pair of boots off Facebook Marketplace. I knew my size from trying them on in-store and scoured Marketplace diligently for months before finally pulling the trigger on a brand new pair selling for three-quarters retail price. I went to the Upper East to get them, handed over the cash, and they were mine.

I wore them around the house for a few days, did chores in them. They didn't feel quite right. I wanted more space in the toebox than they afforded me, and I hated how hard it was to take the shoe off. I wasn't as enamored with the look as I thought I'd been. Within days, I listed them on Marketplace, and not even a week after I'd gotten hands on them, I let them go.

This whole ordeal is illuminating to me. I live in a city where it is easy to get almost anything you want: pretty much every brand has a flagship store here, and the secondhand and used market is very much alive and well. And for as hard as I have tried, I have succumbed to many of its wiles. What have I learned? I get things I think I want; I realize I don't want them; and I get rid of them, sometimes at significant cost to myself (in time or money). Then my brain fixates on something else and the cycle begins anew.

It's not that I didn't know this before. I complain about it all the time. Being here just accelerates this cycle so I can see it for the farce it is. I suppose being able to get rid of stuff I realize I don't want and learning about myself in the process is not entirely a bad thing. But what stands out to me most is how much time and energy and attention I waste desiring things I don't even end up wanting or enjoy owning. I wish I could turn these desires off, or at least channel them into more productive pursuits like reading or writing or making music. I haven't figured this out yet. Some things help, like avoiding advertising and forums that center around a material hobby. But you can't run away from advertising forever. The ideas of nice things always worm their way into my head eventually.

Something else I noticed after buying the boots is that I was extremely cautious not to wear them outside or otherwise use them in ways that would show signs of wear, lest I decrease the resale value. Had I been somewhere I wouldn't have been able to sell them, I might have worn them longer, broken them in, learned to love the way they looked and felt. But here, with the possibility of getting rid of them looming a click away, I'm picky. Something to be said here about the illusion of choice, I guess.

Everyone Online Is Lying

2026-02-05 04:30:00

The average 25 year old isn’t making $100K a month or even in a year.

Most are making like $20K-$40K a year.

Some are making less.

Some are still figuring out what they even want to do.

But if you’re online all day, you’d think everyone your age is a millionaire.

Every other post is someone flexing their revenue/ lifestyle.

Their “I’m 17 making 500k a month” bullshit.

Can’t even lie I do the same…

And it creates this warped reality where you feel like you’re failing because you’re not there yet.

For every “22-year-old millionaire entrepreneur” with a Lambo, there are millions of 22-year-olds struggling to even make rent money.

You’re not behind.

You’re just comparing yourself to people who have extreme advantages one way or another.

Chasing six figures just because the internet told you to is sad.

I’m not saying don’t be ambitious.

I’m not saying don’t want more.

I’m saying build something that you’ll eventually love building.

Because the truth is, most of those people flexing online?

They’re miserable too.

Stop letting Instagram convince you that you’re failing.

Build at your own pace.

It’ll work out eventually, now or 5 years from now.