2026-02-20 08:00:00
| LOC | Host | HM | ADTs | Match | Cl. | Target | ||
|---|---|---|---|---|---|---|---|---|
| Hirrolot's CoC | src | ~70 | OCaml | ✗ | ✗ | ✗ | ✓ | Interpreter |
| Harrop MiniML | src | ~100 | OCaml | ✗ | ✗ | ✗ | ✗ | LLVM → native |
| Algorithm W | src | ~300 | Haskell | ✓ | ✗ | ✗ | ✗ | Type checker only |
| tomprimozic/type-systems | src | ~300 | OCaml | ✓ | ✗ | ✗ | ✗ | Type checker only |
| lambda-calculus-hs | src | ~200–900 | Haskell | ✗ | ✓ | ✓ | ✓ | Interpreter |
| THIH | src | ~429 | Haskell | ✓ | ✓ | ✓ | ✗ | Type checker only |
| Simple-sub | src | ~500 | Scala | ✓ | ✗ | ✗ | ✓ | Type checker only |
PLZoo poly |
src | ~500 | OCaml | ✓ | ✗ | ✗ | ✓ | Interpreter |
| EYG | src | ~500 | Gleam | ✓ | ✓ | ✓ | ✓ | Interpreter |
| Pico-ml | src | ~500 | TypeScript | ✓ | ✗ | ✗ | ✓ | WebAssembly |
| TinyML | src | <700 | SML | ✓ | ✗ | ✗ | ✓ | Interpreter |
| Eff | src | ~1–2K | OCaml | ✓ | ✓ | ✓ | ✓ | Interpreter |
| Frank | src | ~1–2K | Haskell | ✓ | ✓ | ✓ | ✓ | Interpreter |
| Grace | src | ~1–3K | Haskell | ✓ | ✗ | ✗ | ✓ | Interpreter |
| Hackett | src | ~1–3K | Racket | ✓ | ✓ | ✓ | ✓ | Racket runtime |
| Scrapscript | src | ~1–3K | Python | ✓ | ✓ | ✓ | ✓ | C/WASM/Cosmo native |
| MinCaml | src | ~2,000 | OCaml | ✓ | ✗ | ✗ | ✓ | x86/SPARC/PPC native |
| Ben Lynn | src | ~2,000 | Haskell/C | ✓ | ✓ | ✓ | ✓ | Combinators → C VM |
| 1ML | src | ~3–5K | OCaml | ✓ | ✗ | ✗ | ✓ | Interpreter |
| mlml | src | ~3–5K | OCaml | ✗ | ✓ | ✓ | ✓ | x86-64 native |
| Dhall | src | ~4K | Haskell | ✗ | ✓ | ✓ | ✓ | Normalizer |
| Ante | src | ~5–10K | Rust | ✓ | ✓ | ✓ | ✓ | Cranelift → native |
| Tao | src | ~5–10K | Rust | ✓ | ✓ | ✓ | ✓ | Bytecode interpreter |
| Austral | src | ~5–10K | OCaml | ✗ | ✓ | ✓ | ✓ | C |
| AQaml | src | ~5–8K | OCaml | ✗ | ✓ | ✓ | ✓ | x86-64 native |
| Borgo | src | ~5–10K | Rust | ✓ | ✓ | ✓ | ✓ | Go source |
| polytt | src | ~5–10K | OCaml | ✗ | ✓ | ✓ | ✓ | Interpreter |
| Newt | src | ~7K | Newt | ✗ | ✓ | ✓ | ✓ | JavaScript |
| HaMLet | src | ~10–15K | SML | ✓ | ✓ | ✓ | ✓ | Interpreter |
| SOSML | src | ~10–15K | TypeScript | ✓ | ✓ | ✓ | ✓ | Browser interpreter |
| MicroHs | src | ~15–30K | Haskell/C | ✓ | ✓ | ✓ | ✓ | Combinators → C/JS |
I adore small programming languages. Iota is two combinators. tinylisp is 99 lines of C. milliForth is 340 bytes. Fractran multiplies fractions. Oh, K?
I've encountered tiny implementations of Forth, Lisp, C, Prolog, etc., but never "milliHaskell".
Yes, I'm still slowly working on scrapscript.
ML-style languages carry a pungent monad odor that attracts mathochists. Notable examples include Haskell, Elm, F#, Scala, and OCaml. They're "Lambda Calculus with syntactic sugar", i.e. functional and statically-typed. Most implementations extend Hindley-Milner type inference with algebraic data types, pattern matching, and closures:
| Feature | LOC | Dependencies | References |
|---|---|---|---|
| Integer arithmetic | ~50 | Parser, codegen | MinCaml |
| Floating-point | ~100 | Parser, codegen (SSE/NEON) | MinCaml |
| Booleans + if/then/else | ~50 | Parser, codegen | Everything |
| Let bindings | ~30 | Parser, normalization | Everything |
| First-class functions (closures) | ~200 | Closure conversion, runtime | MinCaml |
| Recursive functions (let rec) | ~50 | Type inference (occurs check), codegen | MinCaml |
| Tuples | ~100 | Parser, type inference, codegen | MinCaml |
| Arrays | ~100 | Parser, runtime (bounds checking) | MinCaml |
| Monomorphic type inference | ~100 | Unification | MinCaml |
| Polymorphic type inference (HM) | ~300 | Generalization, instantiation | Algorithm W, PLZoo |
| Algebraic data types | ~200–400 | Parser, type checker, runtime (tagging) | HaMLet, Tao |
| Pattern matching (basic) | ~200 | Exhaustiveness check, case trees | Tao, Ante |
| Pattern matching (optimized) | ~400–600 | Maranget's algorithm | OCaml, Rust |
| Type classes | ~500–2000 | Dictionary passing, instance resolution | MicroHs, Ben Lynn |
| Modules (basic) | ~500–1000 | Namespace management | HaMLet |
| Modules (functors/signatures) | ~2000–5000 | Type-level computation | HaMLet, 1ML |
| Row polymorphism | ~300–800 | Extended unification | EYG, type-systems |
| Algebraic effects | ~500–1500 | Effect typing, runtime support | Eff, Frank, Ante |
| Algebraic subtyping | ~500 | Polar types, biunification | Simple-sub |
| Linear types | ~600 | Linearity checker | Austral |
| Lazy evaluation | ~300–500 | Thunks, memoization runtime | MicroHs, Ben Lynn |
| Garbage collection (Cheney) | ~200 | Runtime system | Most |
| Tail call optimization | ~50–100 | Codegen (jump instead of call) | MinCaml |
| Inline expansion | ~100 | Normalization pass | MinCaml |
| Dead code elimination | ~50 | Free variable analysis | MinCaml |
| Totality checking | ~300–500 | Coverage analysis, termination checker | Tao, Dhall |
Further reading:
If you want a milliHaskell, all your inspiration/ingredients are right here.
🤖 The most extreme capability-to-size ratio in this list — a complete Calculus of Constructions (the type theory at the top of the lambda cube) with bidirectional typing, dependent function types, and a type-in-type universe, all in a single OCaml gist of ~60–80 lines. It can express length-indexed vectors and other dependently typed programs. Not ML-family per se, but it demonstrates that full dependent types need not be complex to implement.
🤖 MiniML demonstrates the absolute floor for a native-code ML compiler. Using Camlp4 for parsing and OCaml's LLVM bindings, it supports integer arithmetic, conditionals, and recursive first-order functions. Xavier Leroy noted the critical caveat: this is not truly "Mini-ML" since it lacks higher-order first-class functions — adding closures and garbage collection would significantly expand the codebase. Still, it shows what LLVM enables in ~100 lines.
🤖 Algorithm W Step by Step by Martin Grabmüller (~300 LOC, literate Haskell) is the canonical educational implementation of Algorithm W for Hindley-Milner type inference. Self-contained, well-commented, and widely referenced — this is where most people first implement HM inference.
🤖 A collection of standalone implementations of several inference algorithms in OCaml (~300–600 LOC total): basic Algorithm W, row polymorphism (the technique foundational to Elm's original type system), and HMF (first-class polymorphism with partial inference). Each variant is self-contained in a single directory. Where Algorithm W Step by Step teaches you one algorithm well, this repository shows you what changes when you swap in more powerful type system features.
🤖 A progressive collection of single-file lambda calculus implementations in Haskell (~200–900 LOC each) by Solomon Bothwell. Starts with simply typed evaluation and builds incrementally through bidirectional typechecking, normalization by evaluation (NbE), System T, records with depth subtyping, and nominal inductive types with dependent pattern matching. Each implementation is self-contained. Where tomprimozic/type-systems varies the inference algorithm, this repository varies the type system while keeping bidirectional checking as the constant.
🤖 Typing Haskell in Haskell by Mark P. Jones is the definitive executable specification of Haskell 98's complete type system in just 429 lines of core Haskell. It covers kinds, qualified types, type classes, pattern matching types, binding groups, mutual recursion, and defaulting. For context, the Hugs type checker implementing the same semantics spans 90+ pages of C. THIH is a type checker only (no evaluation), but its density of specification per line of code is unmatched.
🤖 ~500 LOC of Scala. Lionel Parreaux's clean reimplementation of Stephen Dolan's MLsub — algebraic subtyping that adds union and intersection types to Hindley-Milner while preserving principal types. No annotations required. The original MLsub won POPL 2017; Simple-sub distills it into an ICFP 2020 Pearl that's small enough to read in one sitting. The ancestor of MLscript, which grows the idea into a full language with OOP and TypeScript interop.
poly
🤖 ~400–600 LOC, OCaml. Implements a lazy, purely functional language with parametric polymorphism and HM type inference. Its sibling
miniml(~300–500 LOC) includes a compiler targeting an abstract machine. Both are part of Andrej Bauer's Programming Languages Zoo, which contains 12+ miniature language implementations, each a few hundred lines of OCaml, covering everything from untyped lambda calculus to call-by-push-value.
🤖 ~500 LOC JavaScript interpreter, full implementation in Gleam. EYG ("Eat Your Greens") by Peter Saxton prioritizes predictability, portability, and crash-free programs. It uses row-typed inference (HM extended with row polymorphism), algebraic effects as the sole FFI mechanism, and closure serialization — functions can be sent to other machines for tierless client/server programming. The most distinctive feature: programs are stored as JSON ASTs, not text files. A structural editor makes it impossible to write syntactically invalid programs.
🤖 An OCaml subset with HM type inference that compiles to WebAssembly, implemented in TypeScript. Small and self-contained — unusual for having a TypeScript host language rather than the OCaml/Haskell norm. A good starting point if you want to understand ML compilation targeting the browser.
🤖 Packs a lexer, parser, interpreter, and full polymorphic HM type checker into under 700 lines of SML. Referenced on Lambda the Ultimate, this may be the smallest complete implementation with genuine Hindley-Milner inference, though the original download link appears to have gone stale.
🤖 The original algebraic effects language (2012) by Andrej Bauer and Matija Pretnar. OCaml syntax with effect handlers as first-class constructs — you declare effect operations, then install handlers that give them meaning. This is where the idea was first made concrete in a running implementation. Koka, Frank, OCaml 5's effect handlers, and virtually every subsequent algebraic effects system trace lineage here.
🤖 "Do Be Do Be Do" (POPL 2017) by Sam Lindley, Conor McBride, and Craig McLaughlin. A strict effectful functional language where functions are handlers that handle zero effects — and multihandlers generalize function abstraction to handle multiple effect interfaces simultaneously. The insight: the boundary between "function" and "effect handler" is artificial. Implemented in Haskell. Lindley describes it as "the one I'm most fond of" while noting it's "basically unmaintained." That tension between conceptual elegance and practical neglect is the story of many languages on this list.
🤖 A JSON superset with bidirectional type checking and row polymorphism, by Gabriella Gonzalez (author of Dhall). Designed explicitly as a "ready-to-fork" language skeleton — if you need a typed DSL, clone Grace and customize it. Has open records, open unions (polymorphic variants), and a clean Haskell codebase that reads like a tutorial. No Hindley-Milner per se (bidirectional instead), but closely related.
🤖 A Haskell-like language implemented entirely as Racket macros via the "Type Systems as Macros" technique, by Alexis King. Bidirectional type inference, algebraic datatypes, pattern matching, typeclasses, higher-kinded types, and higher-rank polymorphism — all implemented not as a separate type-checker pass but as macro expansion. The meta-angle is the story: types as macros rather than a traditional elaboration pipeline.
🤖 A content-addressable pure functional language where every expression reduces to a cryptographic hash, stored in a decentralized "scrapyard" registry and referenced by hash or alias. The implementation is a ~1,300-line dependency-free Python interpreter in a single file, with a baseline compiler to C (~500 LOC) and an SSA IR with SCCP/DCE optimization (~1,000 LOC). Pattern matching is the sole control-flow mechanism. Compiles to C, WebAssembly, and Cosmopolitan portable executables. Implemented primarily by Max Bernstein.
🤖 ~2,000 LOC, OCaml → native code. The gold standard for capability-to-code-size ratio. Written by Eijiro Sumii at Tohoku University, it implements a strict, higher-order functional language with type inference, closures, tuples, arrays, tail-call optimization, inline expansion, constant folding, and graph-coloring register allocation. It compiles to SPARC, PowerPC, and x86 assembly. On benchmarks including a ray tracer, MinCaml-compiled code runs within 2× of GCC and OCaml's
ocamlopt— sometimes faster. The deliberate trade-off: it omits polymorphism, algebraic data types, and pattern matching. Used in undergraduate compiler courses at the University of Tokyo since 2001, where students build ray tracers compiled by their own compilers running on custom CPUs.
🤖 ~2,000 lines of Haskell + 350 lines of C. Arguably the most remarkable bootstrapping achievement in this space. Starting from a 350-SLOC C runtime that interprets combinatory logic, Lynn builds a chain of approximately 20 progressively more capable compilers, each written in the subset of Haskell that the previous compiler can handle. The final compiler supports type inference, type classes, algebraic data types, pattern matching, guards, where clauses, monadic I/O, modules, and layout parsing — approaching Haskell 98 coverage. It compiles Haskell to combinatory logic via Kiselyov's bracket abstraction algorithm, with graph reduction evaluation. Later stages even target WebAssembly. The entire bootstrapping chain is reproducible from just a C compiler.
🤖 ~3,000–5,000 LOC, OCaml. Andreas Rossberg unified ML's core and module layers into a single language where modules are first-class values, types are values, and functors are ordinary functions. It elaborates to System Fω with HM-style inference. Won the ICFP Most Influential Paper Award in 2025. A proof-of-concept interpreter, not optimized, but a conceptual breakthrough in minimal surface area.
🤖 A self-hosting OCaml subset compiler targeting native x86-64. ~3,000–5,000 LOC. Supports pattern matching, algebraic data types, recursive functions, and closures. Does not implement type inference — it demonstrates the minimum OCaml subset needed for self-compilation.
🤖 A total (non-Turing-complete) typed configuration language. ~4K LOC core Haskell. Normalization is guaranteed to terminate — you can always reduce a Dhall expression to a normal form, which means imports resolve, functions inline, and what you get is plain data. Based on a Calculus-of-Constructions-derived type theory with records, unions, and natural numbers. Has a formal specification and implementations in Haskell, Rust, Go, and Clojure.
🤖 Combines HM type inference, algebraic data types, pattern matching, algebraic effects, and an ownership-like system for shared mutability. Written in Rust, it uses Cranelift for native code generation. Actively developed, aiming to bridge the Rust/OCaml divide.
🤖 Surprisingly feature-rich for its size: generics, typeclasses, sum types, pattern matching, first-class functions, currying, algebraic effects, associated types, and totality checking. Its pipeline runs from lexing through HIR type inference to MIR monomorphization and bytecode execution. Written in Rust.
🤖 A systems language with linear types and capability-based security. The linear type checker is ~600 lines. OCaml bootstrap compiler targeting C. Designed by Fernando Borretti to fit in one person's head — the spec is deliberately small enough that a single developer can understand the entire language. Not functional in the Haskell sense, but linear types make it adjacent. An experiment in "what if we took linear types seriously but kept the language small."
🤖 A self-hosting OCaml subset compiler targeting native x86-64. ~5,000–8,000 LOC. Adds records, variants, references, and garbage collection beyond what mlml supports. Triple self-hosting verified. Like mlml, it omits type inference — demonstrating the minimum OCaml needed for self-compilation.
🤖 Adds ML-family features (algebraic data types, exhaustive pattern matching, Result/Option types) to Go's ecosystem by compiling to Go source code with Rust-like syntax. Written in Rust.
🤖 A research experiment from the Topos Institute extending Martin-Löf Type Theory with native, first-class polynomial functors — the mathematical objects underlying deterministic state machines and interactive systems. Written in OCaml with Menhir parsing. Custom syntax for polynomial types (
y^n), morphism arrows, and wiring operators. Dependent types (Pi, Sigma), finite-set ADTs, and pattern matching via case elimination. An ended experiment, but a unique point in the design space: what happens when you make polynomial functors a language primitive rather than an encoding.
🤖 ~7K LOC, self-hosted, compiles to JavaScript. A dependently typed language with Agda/Idris/Haskell-like syntax by Steve Dunham. Bidirectional typechecking with normalization by evaluation (based on Elaboration Zoo), typeclasses, ADTs with dependent pattern matching, case tree compilation, trampoline-based TCO for mutually tail-recursive functions, and erasure of compile-time-only values (0/ω quantities). Has a web playground and an LSP. The compiler is written in Newt itself. Built as a learning exercise, but the feature set — self-hosting, dependent types, typeclasses, erasure, LSP — puts it well beyond most pedagogical implementations.
🤖 ~10,000–15,000 LOC, SML. Andreas Rossberg's most faithful implementation of the Definition of Standard ML. It implements all of SML '97 including the full module system (signatures, structures, functors), mapping rule-by-rule to the formal Definition. Jeremy Yallop recommends it as the most readable SML implementation. It can be bundled into a single SML file and compiled by any SML implementation. A
compile-jsbranch demonstrates compilation to JavaScript.
🤖 ~10,000–15,000 LOC, TypeScript. Implements the full SML core language in the browser: val/fun/datatype declarations, pattern matching, HM type inference, exceptions, and references. Used for teaching at Saarland University.
🤖 By Lennart Augustsson (one of GHC's original creators) — the most complete "small" Haskell compiler alive today. It compiles an extended subset of Haskell 2010 including type classes, do-notation, deriving, record syntax, overloaded literals, and modules. It is fully self-hosting and — critically — bootstrappable from only a C compiler (no pre-existing Haskell toolchain required). MicroHs translates Haskell to combinators executed by a C runtime. It has a JavaScript runtime target, a package manager (
mcabal), and can compile real Hackage packages like QuickCheck. The codebase is not trivially small (estimated 15,000–30,000 lines across compiler, libraries, and runtime), but for what it does — a near-complete Haskell compiler bootstrappable from C — it is remarkably compact.
2026-02-17 08:00:00
Somebody is in big trouble. Google's official iOS App just sent this [very] NSFW link to lots of people. It's an AI-generated Grok Imagine video of a woman with the prompt "Singing a song and teasing with her tongue". Yikes.
Nobody's reporting on this yet, but it's ominous that YouTube and Google Trust Services are experiencing simultaneous outages. Stay tuned.
I just got a notification from Google that said ‘Grok’. No subtext or anything in the notification. I clicked on it, knew I probably shouldn’t, and it took me to a gif of some girl with her tongue out and a shirt on but with her rack in the camera. Anyone else? What is this? Does my phone have a virus now?
-- via r/iphone
Earlier today I had this notification from google of ‘Grok’ and I opened it to a AI generated girl with her tongue out. Am I being hacked? I’m quite scared. I changed all my passwords but want to know if anyone else had this?
-- via r/cybersecurity
Did anyone else just get that grok notification?? Literally just said “grok” and when you click on it it’s a girl in a white tank top licking towards the screen like wtf? I don’t even use grok or twitter really for that matter so I’m beyond confused
-- via r/grok
I don't know where to post this but has anyone else gotten a weird google notification that just says grok and then it links to a Twitter post of some girl sticking out her tongue provocatively? I'm assuming the porn bots have found a new way to spam through the Google app. I just want to know I'm not alone
-- via r/Destiny
What does this Google notification named “Grok” mean?
-- via r/AskReddit
I have never used grok, never even searched it, and I saw a notification on my phone from Google (I attached the image). Out of curiosity, I clicked it and it immediately opened up to this, with the chat already written out and everything. Has this ever happened to anyone? It was legit a jump scare. My boyfriend thinks it is hysterical, I am more concerned than anything
-- via r/grok
i got a completely unsolicited notification this morning/overnight in the google app that said ‘grok’. normally these notifications have more detail, giving info from a news article, but this one simply said grok. i knew it was to do with grok ai but assumed it might have been an article so i clicked on it to read in case there was any update.
it was literally p*rn. granted the ai generated person was clothed, but it was exactly that, with pre-filled chat below that suggested to make things much more graphic too.
i can’t help but worry about the potential for this to have reached the phones of minors? ntm the fact in a lot of countries this would count as a form of assault.
is it a bug? security breach? do i need to change passwords? i know some people might find it funny but i’m feeling really unsettled by this :-(
i tried sharing this in the google sub but it was auto modded
-- via r/internet
2026-02-14 08:00:00
To converse with yourself is to give yourself a lousy backrub. You need people.
And they need you. Other people exist; they want to feel valuable too.
Quality conversations are great gifts. But conversing is expensive -- you must pay attention, but attention is your only scarce resource. Attention is all you need, and it's all you have. You are what you attend to.
But your attention runs wild. It acts without permission. Your hopes/fears rule your life. You expect too much; you assume even more. Again and again, your attention folds itself into a helicopter hairball of faulty memories, of blind beliefs, of opiate fantasies.
You probably can't ever fully unfurl. All your best attempts to detangle yourself add more knots. Sometimes you give up and turn into a puddle of goo. It feels nice to be a puddle on occasion.
Every good conversation can start precisely wherever you are: life is good. Yes, life is good. Admit it, and be grateful. Or curious.
That's a human. Weird. Are they alive? What are they feeling? What led them here? Why are they folding into a hairball? Why are they so afraid of living?
What do they really want? What is stopping them? What support do they need?
Reflect their ideas. Find their helicopter in the surface of your puddle, and capture it with your words. "It sounds like you resent your parents for sending you to clown school." No prescriptions, no advice, no opinions -- no, no, you're not listening.
Now it's your turn. Valuable attention is being paid to you. If a friend watches your helicopter through their puddle, make it worth their while. Do a spectacular aerial maneuver. Or maybe share something deep and personal. Sharing yourself is more difficult than it seems -- the most painful knots in your hairball are so embarrassing, so terrifying, so overwhelming. But that's the point. Accept the backrub, you fool.
2026-01-25 08:00:00
- They're not even real trees
- Cockroaches live inside them, meaning your home will likely be infested if you have palms in the yard
- They are a pain in the ass to maintain, and it costs a lot to get someone else to do it
- Wasps nest in the leave fronds
- They provide way less shade than large trees like maple or oak
- Most species are generally ugly. I can't speak for other tropical places in the world, but the ones in south Texas look scraggly and gross
- I hate them
I have case studied [anti-palm-tree sentiment] quite well and I have discovered multiple causes. Palms do not produce in our latitudes anything with economical interest (fruits, oil). Palms do not produce big colorful flowers. Palms do not create deep shade. Many of us (if not all) try also more marginal spss which do not have a very decorative effect (if not at all). Palms need more care in summer, when people want to go on vacation and of course they are more or less cold sensitive. Many palms have spiny leaves and their fronds are not suitable for composting, so a dicard of pruned leaves is a problem itself. Now if you add recent problems with pests in Europe (rpw and paysandisia), meaning dead, ugly plants (whose removal is also troublesome- have you ever tried to cut down a freshly dead CIDP?) or constant spraying, which neighbouts have to endure, all becomes explicable.
via palmtalk.org
I just despise palm trees. They're so stupid, so incredibly dumb, I hate them. They think they're so cool with their fronds and weird scaly bark. They try so hard to look nice but guess what? It isn't working. They're the tree equivalent of a skin disease. They just look stupid. Why do they grow leaves just on the top? Out of all the diverse branch and leaf designs in the tree world they chose the bowl cut?
And hey, fun fact: they aren't even real trees. They're a variety of overgrown grass! They're phonies, fakers, shams. They're just giant grasses trying to make it in the tree world and they can't. It's just not their destiny, and yet they fight so hard. It's a little funny, a little sad.
You ever see a good Douglas Fir? Or a hearty maple? Now those are real trees. Big strong trees. They know their place in the world and they embrace it. I can respect them, unlike palm trees.
Now, don't get me wrong, I can tolerate them in their natural habitats, I respect mother nature. But I especially hate when they're brought into a completely separate climate. I live in the Pacific North West, and I still see palm trees. They don't belong here! And they can't properly grow here (not that there's anything proper about them anywhere) and they just end up stunted and uglier. I hate them, I hate them so much.
Every time I see one rage just begins to rise, just a little. I'm not overwhelmingly angry, but it's a cold hatred. Me and the palm trees are at a stalemate. I can't legally attack them, and they can't move, but I have no doubt if they could they would attack me and I likewise would attack them. If my friend was cursed into the form of a palm tree, I'd do everything in my power to change them back because no one deserves that pain, but failing that I'd put them out of their misery. I don't believe in a palm tree hell: they already exist in constant pain. I pity them, yes, but I hate them.
If there is a creator, either I fail to see their designs or they're a cruel maker for inventing such a horrible creature/plant. Their presence is a punishment both to themselves and the world, a divine reminder of man's mortality and our hubris. I hate them, I hate them so much.
I exaggerate a small bit but I do hate palm trees. This is not a meme. If I had one wish, even if I were on my deathbed, I'd wish them all to die and we'd perish together rather than I waste my wish on self-preservation. And you should hate them too.
via r/teenagers
2026-01-06 08:00:00
Hey. It's been a while.
I've been meaning to reach out, but work and the kids -- you know how it goes.
I think about you surpringly often. Yesterday I saw a lone coconut at the grocery store and I literally guffawed. After all these years, I still don't know how to open a stupid coconut. I hope coconuts still baffle you too. I miss being idiots together.
The truth is, I've been avoiding you. I miss you, but I'm afraid that you've changed as much as I have. I don't want to admit that maybe our magic is gone forever. Wallowing in nostalgia has been easier than feeling like this and writing it down.
I know that someday all my best memories will be behind me, but I'm not ready for that to happen yet. Not yet. Not this year.
Anyway, I'm feeling more optimistic now after a few glasses of wine. I've got big plans for 1996.
Let's catch up soon?
Happy belated new year.
