In Fongbe, a language spoken by roughly two million people in Benin and parts of Togo and Nigeria, there is a phrase: "E flin nu." It means "It remembers things."
The word "flin" carries the weight of memory -- not the computer science kind, measured in gigabytes, but the human kind: the act of holding something in mind, of not letting go. In Fongbe culture, as in many West African traditions, the elephant is the animal that embodies this quality. The elephant walks slowly, but it arrives. It is patient, but it is powerful. And it never forgets.
When we needed a name for a programming language whose core architectural principle is that everything is persisted and has history, the name was already there. It had been there for centuries, spoken in the markets of Cotonou and Abomey, long before anyone thought to build a computer.
This is the story of how a Fongbe word became the name of a programming language -- and how that name shaped the language's design.
The Anatomy of a Name
The phrase "E flin nu" breaks down as follows:
E flin nu
| | |
| | +-- "things" / "stuff"
| +---------- "remember" / "not forget"
+--------------- "it" (third person singular)
Translation: "It remembers things"The verb "flin" is the operative word. It does not mean "store" or "record" or "persist" -- those are mechanical operations. It means "remember," which implies understanding, context, and continuity. A database stores rows. An elephant remembers experiences. The distinction matters.
Thales grew up in Benin, where Fongbe is one of the national languages. The decision to name the language after a Fongbe word was not a marketing exercise in cultural branding. It was a statement of origin: this language was conceived in West Africa, by a West African, to solve problems that West African developers face every day. It carries its origin in its name, in every file extension, in every command typed into a terminal.
app.flin -- four characters that encode a philosophy, a culture, and an architecture.
Why Names Matter in Language Design
Every successful programming language has a name that, whether deliberately or accidentally, communicates something essential about its character.
Python is named after Monty Python. The message: programming should be fun, accessible, even humorous. Python's design reflects this -- it reads like pseudocode, it prioritizes readability, and its community culture is welcoming.
Rust evokes the organic process of oxidation -- something that emerges from the interaction of elements over time. Rust the language is about systems that must endure, about safety that emerges from strict rules.
Go is simple, short, and direct -- like the language itself. Two letters, no ceremony.
FLIN evokes memory. Not coincidentally, memory-native design is the single most distinctive feature of the language. The name is not a label applied after the fact; it is the seed from which the design grew.
When we began designing FLIN's entity system -- the replacement for ORMs like Prisma and TypeORM -- the name kept pulling us toward a specific question: what would it mean for a programming language to truly remember?
The answer became temporal queries.
Memory-Native Design: The Elephant's Gift
In every other programming language, data exists only in the present tense. When you update a row in PostgreSQL, the old value is gone. When you modify a JavaScript object, its previous state vanishes. If you want history, you build it yourself: audit tables, event sourcing, change data capture, temporal database extensions.
FLIN rejects this. In FLIN, every entity has history by default, because the language remembers.
flinentity Product {
name: text
price: money
description: semantic text
updated: time = now
}
// Create a product
save Product { name: "FLIN Handbook", price: 2500 }
// Later, update the price
product = Product.where(name == "FLIN Handbook").first
product.price = 1900
save product
// The old price is not gone. The elephant remembers.
oldProduct = product @ -1
oldProduct.price // 2500 -- the previous version
// Query the product as it was yesterday
productYesterday = product @ yesterday
// Or on any specific date
productLastMonth = product @ "2026-02-26"
// Or see the complete history
{for version in product.history}
<div>
<span>{version.updated}</span>
<span>{version.price}</span>
</div>
{/for}The @ operator is FLIN's temporal access syntax. It is the most visible expression of the naming philosophy: the language remembers things, and it gives you a one-character operator to access those memories.
Consider what this replaces in a traditional stack. To implement the same functionality with PostgreSQL and Prisma, you would need:
sql-- PostgreSQL: Create an audit table
CREATE TABLE product_history (
id SERIAL PRIMARY KEY,
product_id INTEGER REFERENCES products(id),
name TEXT,
price DECIMAL,
changed_at TIMESTAMP DEFAULT NOW(),
operation VARCHAR(10)
);
-- Create a trigger function
CREATE OR REPLACE FUNCTION track_product_changes()
RETURNS TRIGGER AS $$
BEGIN
INSERT INTO product_history
(product_id, name, price, operation)
VALUES
(OLD.id, OLD.name, OLD.price, TG_OP);
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
-- Attach the trigger
CREATE TRIGGER product_audit
AFTER UPDATE OR DELETE ON products
FOR EACH ROW EXECUTE FUNCTION track_product_changes();Thirty lines of SQL, a trigger function, an audit table, and you still need application code to query the history. In FLIN, the same capability is zero lines of configuration because it is built into the entity keyword.
The elephant never forgets. Neither does FLIN.
The Elephant in Beninese Culture
To understand why the elephant resonates so deeply as a symbol for FLIN, you need to understand what the elephant means in the cultures of Benin.
The Kingdom of Dahomey, which existed in what is now Benin from approximately 1600 to 1904, adopted the elephant as a royal symbol. King Ghezo, who ruled from 1818 to 1858, used the elephant as his personal emblem. His praise name included a reference to the elephant's strength: an elephant that the forest cannot contain.
In Fon cosmology, the elephant represents several qualities simultaneously:
- Memory -- the elephant does not forget paths, water sources, or threats, even after decades
- Strength -- not the aggressive strength of a predator, but the patient, enduring strength of the largest land animal
- Wisdom -- elephants are led by matriarchs who remember drought cycles, migration routes, and safe terrain
- Community -- elephants travel in groups, protect their young, and mourn their dead
These qualities map surprisingly well onto what a programming language should be:
- Memory -- FLIN remembers every version of every entity
- Strength -- FLIN's Rust runtime is fast, safe, and production-grade
- Wisdom -- FLIN's
askkeyword uses AI to translate intent into queries - Community -- FLIN is designed for the global developer community, starting with Africa
The elephant is not a mascot. It is the architectural diagram.
The Name Shaped the Architecture
Names are not neutral. A name creates expectations, and those expectations shape design decisions. When we named the language FLIN -- "It remembers things" -- we committed ourselves to making memory a first-class concept.
This commitment had concrete consequences:
Consequence 1: FlinDB must be embedded. An external database cannot provide memory-native semantics transparently. If the user has to configure a PostgreSQL connection, the promise of "it remembers" is broken by setup friction. FlinDB is embedded in the FLIN runtime, powered by the ZEROCORE engine, requiring zero configuration.
Consequence 2: History must be automatic. If the user has to opt into history tracking per entity, most will not bother, and the language's core promise becomes optional. In FLIN, every entity tracks history by default. You cannot create an entity that forgets.
Consequence 3: Temporal queries must be syntactically cheap. If querying history requires a verbose API call, developers will avoid it. The @ operator -- a single character -- makes temporal access as easy as field access. user.name gives you the current name. (user @ yesterday).name gives you yesterday's name. The cognitive cost is nearly zero.
Consequence 4: The save keyword must be explicit. If FLIN remembers everything, then the act of creating a memory must be intentional. You do not accidentally persist data. You write save user, and a new version is created. This is the difference between a language that silently tracks state and one that gives the developer control over what constitutes a meaningful checkpoint.
flin// These two lines create exactly one history entry
user.name = "Juste A. GNIMAVO"
save user
// Modifying without saving creates no history entry
user.email = "[email protected]"
// The change exists in memory but is not yet rememberedThis is the elephant's gift to language design: a name that is not just a label, but a contract. Every feature we add to FLIN is tested against the question: "Does this make the language remember better?"
Africa-First, World-Ready
Naming a programming language after a Fongbe word is a deliberate choice to center Africa in the narrative of programming language design.
Most programming languages are named in English, designed in the United States or Europe, and optimized for developers with fast internet, powerful hardware, and access to the latest tools. The implicit assumption is that the "default developer" lives in San Francisco or London.
FLIN starts from a different assumption: the default developer lives in Abidjan, Cotonou, Lagos, Nairobi, or Dakar. They have intermittent internet. They pay per megabyte. Their power supply is unreliable. Their hardware is three generations behind Silicon Valley.
The name signals this. When a developer in Lagos sees app.flin for the first time and learns that the name comes from Fongbe -- a West African language -- there is a recognition: this tool was made for me. Not adapted for me. Not localized for me. Made for me, from the beginning.
This is not merely symbolic. The Africa-first design constraint produces objectively better software:
Constraint from Africa Benefit for everyone
----------------------------------- ----------------------------------
Slow internet (2 Mbps) Zero dependencies, tiny binary
Expensive data (per MB) No npm install, no updates to download
Unreliable power Fast compilation, no long builds
Limited hardware Small memory footprint
Offline-first requirement Embedded database, no server needed
Mobile-first users PWA support built inFLIN's zero-dependency architecture is not a compromise made for emerging markets. It is a design decision that makes the language better for every developer on the planet. A developer in Berlin benefits from instant startup times just as much as a developer in Bamako. A developer in Tokyo appreciates the absence of node_modules just as much as a developer in Lomé.
What is good for Lagos is good for London. The elephant taught us that.
The .flin File Extension
There is a quiet satisfaction in the file extension .flin. Four characters. Distinctive enough to be immediately recognizable, short enough to type without friction, and meaningful in a way that .js, .py, and .rs are not.
When you create app.flin, you are not just naming a file. You are invoking the elephant. You are saying: this file will remember. This application will have history. This code will persist.
The extension also serves a practical purpose. No other programming language uses .flin, which means there are zero conflicts with existing tooling. Syntax highlighting, file associations, and editor plugins can target .flin without ambiguity.
flin// counter.flin -- the simplest FLIN application
count = 0
<button click={count++}>{count}</button>This four-line file contains: a reactive variable, an HTML view, an event handler, and automatic DOM updates. Save it, run flin dev, and you have a working application.
The elephant would approve. Simple. Memorable. Complete.
The Fongbe Programming Glossary
FLIN is the first, but it may not be the last. The Fongbe language contains many words that map beautifully onto computing concepts:
Fongbe word Meaning Computing parallel
----------- --------------------- -------------------
flin remember persistence, history
nu thing, stuff data, objects
wa do, make execute, build
kpon look, examine inspect, debug
zun count enumerate, iterate
se hear, understand parse, interpret
gbeta divide, split partition, chunk
kple gather, collect aggregate, queryWe chose "flin" because it captures the most distinctive aspect of the language's design. But the richness of Fongbe as a source of technical vocabulary suggests something larger: African languages are not just valid sources for naming technical products; they are often more expressive and precise than the Latin and Greek roots that dominate computer science terminology.
The word "flin" carries nuance that "persist" does not. "Persist" is mechanical -- data is written to disk. "Flin" is intentional -- the system chooses to remember, the way an elephant chooses to remember the location of a water source it has not visited in twenty years.
The Long Memory
There is one more dimension to the naming story that we have not discussed: the long memory of history itself.
Benin -- formerly the Kingdom of Dahomey -- has a rich intellectual and technological tradition that predates European colonization. The Fon people developed sophisticated systems of mathematics, astronomy, and governance. The Vodun tradition, which originates in Benin, is a complex philosophical system that deals with memory, ancestry, and the persistence of identity across time.
Naming a programming language after a Fongbe word is, in a small way, an act of continuity. It says: the future of technology is being built not just in Silicon Valley, but in Abidjan, Cotonou, and across the African continent. And it is being built not by abandoning cultural heritage, but by drawing on it.
The elephant has been a symbol of memory in West Africa for centuries. Now it is a symbol of memory in computer science.
E flin nu. It remembers things.
And so does the language that bears its name.
Next in the series: Five Design Principles That Shape Every Line of FLIN -- Every language has opinions. FLIN has five, and they are non-negotiable.