Origins: the stories behind the names

A living log of where names come from. The tools we build on, the cryptography we trust, and the words we coined for our own codebase. Half of understanding a thing is knowing why it is called what it is, so this is the curiosity shelf of the project: part onboarding, part easter egg for anyone who wonders "wait, why is it called that?"

How to add to it: when you explain or discover the origin of a name (a tool, a library, a protocol, a concept, or one of our own terms), drop a short entry here. Keep it to a sentence or three, keep it accurate, and prefer the real story over a tidy myth. If you are not certain, say so.

---

Our stack

• XSS (cross-site scripting): the attack where someone else's script runs inside a page you trust, wearing your logged-in badge. It is abbreviated XSS rather than CSS only because CSS was already taken by stylesheets. The name is also a fossil: many modern variants never involve a second "site" at all, but by the time that was clear the name had stuck.

• Python: named for Monty Python, not the snake. Guido van Rossum was reading the "Monty Python's Flying Circus" scripts while looking for a short, slightly mysterious name for his new language, and the comedy troupe won. It is why the docs are peppered with spam, eggs, and dead parrots where other languages would say foo and bar.

• git: Linus Torvalds wrote it in 2005 after the BitKeeper falling-out left Linux without version control. "git" is British slang for an unpleasant, stupid person; Linus joked, "I'm an egotistical bastard, and I name all my projects after myself. First Linux, now git." The man page also offers tongue-in-cheek backronyms like "global information tracker" for when it is working well.

• worktree (git worktree): just "working tree" squished into one word. Your working tree is simply the folder of files you actually see and edit (git keeps the project's history tucked away separately). Normally a repo gives you one. git worktree lets you have several open at once, one per branch, so you can work on two branches side by side without constantly saving and switching.

• --force-with-lease (git): the polite cousin of a force-push. A plain force bulldozes whatever is on the server with your copy, even if a teammate pushed something in the meantime (you would quietly erase their work). "With lease" adds a safety check: it only overwrites if the server still looks exactly like it did the last time you looked. If someone slipped a change in, it stops and warns you. The word "lease" comes from the idea of a claim you hold only as long as nothing has changed underneath you.

• inset (CSS): the shorthand for the four numbers saying how far a box sits from each edge (top, right, bottom, left). Before it existed you wrote all four by hand. The word is the ordinary English one: to "inset" something is to set it in from the edges, the way a photo sits inset from the border of its frame. The part worth remembering is WHICH frame. A box positioned as fixed measures from the edges of the browser window itself, never from whatever container it happens to sit inside, so shrinking that container does not move it at all. That trips people constantly, because nothing errors: the container just quietly has no say.

• JavaScript: Brendan Eich built it at Netscape in 1995 in about ten days. It was called Mocha, then LiveScript, then renamed JavaScript purely as a marketing tie-in to Sun's Java, which was the hot language of the moment. The two are barely related: "Java is to JavaScript as ham is to hamster."

• Vite: French for "quick" or "fast" (pronounced "veet"), from Evan You. The name is the whole pitch: a dev server that starts instantly instead of bundling everything up front.

• Nominatim: Latin for "by name." It is OpenStreetMap's geocoder: you give it a name and it finds the place (or, in reverse, you give it a point and it names the place). We use it to enrich venue data.

• Tailwind (Tailwind CSS): our styling toolkit. The name is the metaphor: a tailwind is wind blowing from behind that pushes you along faster, and the framework aims to be exactly that for building screens. Instead of hand-writing CSS, you snap together tiny prebuilt classes and keep moving.

• Vitest: the tool that runs our *.test.js files. The name is "Vite" plus "test": it runs on top of Vite and reuses the same fast build pipeline, so tests transform code the same way the app does. Like Vite, the name is the whole pitch.

• VitePress: the tool that turns our docs/ folder into the browsable website embedded in the admin portal's Docs tab. The name is "Vite" plus "press", as in printing press. Its predecessor was VuePress (built on the Vue framework), whose name in turn tipped its hat to WordPress, the granddaddy of publishing tools. So the lineage runs press to press: each generation kept the "turn plain text into a published site" idea and swapped the engine underneath for a faster one.

• Storybook: the workbench where each UI piece is shown on its own. Every individual example (a button while loading, the same button disabled, and so on) is called a "story," and the tool gathers them into a browsable book of the interface. Hence Storybook: a storybook of how each component looks and behaves.

• geohash: a way to squeeze a latitude/longitude into a short string of characters, with a handy trick: two places near each other share the same opening characters, so you can find nearby things by matching prefixes. "geo" for location plus "hash" (turning data into a short fixed-length code). Gustavo Niemeyer coined it in 2008 and put it online at geohash.org. We use it (via geofire) to find venues near a point.

• dead letter: in messaging systems, a holding pen for messages that could not be delivered, kept instead of thrown away so someone can look at them later. The name comes straight from the postal service: since the 1820s a "Dead Letter Office" is where undeliverable mail goes, opened by clerks to hunt for clues about the sender. Software borrowed the whole idea, queue and all. Our analytics pipeline uses the concept in miniature: events the server cannot store wait in the browser's local queue for another try rather than vanishing.

• hook (as in .claude/hooks/, and git's pre-commit hooks): a hook is a spot where a system deliberately lets you hang your own code, so it runs by itself whenever some particular thing happens. The metaphor is the coat hook: the program provides the peg, you hang what you like on it. It long predates AI agents. Emacs had -hook variables in the early 1980s, so a user could attach "run this every time a file is opened", and Windows spread the word further with its event-intercepting hooks. The reason ours actually bite is where they live: the check runs inside the program, before the action goes through, so there is nobody to talk out of it.

Cryptography

• Curve25519: Daniel J. Bernstein's elliptic curve, and the 25519 is not decorative: the curve is defined over the prime field 2^255 minus 19. The name literally encodes the math.
• Olm / Megolm: the Double Ratchet implementations behind our encrypted chat (see apps/web/src/lib/signal/olmMachine.js). Olm is named after the olm, a pale, blind salamander that lives its whole life in dark European caves. Megolm is the group-messaging variant: same idea, scaled up. The salamander is not a coincidence: Signal's original protocol was called Axolotl, after the Mexican salamander that can regrow lost body parts, because the protocol "self-heals" its security after a key is compromised. When the Matrix project wrote its own implementation of that same family, it picked another salamander, the olm, quietly keeping the lineage.
• PBKDF2: the name is a plain label for what it does, "Password-Based Key Derivation Function," version 2. It takes a human password and grinds it (for us, 600,000 rounds) into a strong cryptographic key, which is deliberately slow so an attacker guessing passwords has to pay that cost on every guess. The "2" just marks it as the successor to the original PBKDF1. Like Curve25519, the name is the spec.
• AES / Rijndael: AES stands for "Advanced Encryption Standard," the cipher the US standards body chose in 2001 after an open, multi-year competition. The winning design was originally called Rijndael, a blend of its two Belgian inventors' surnames, Vincent Rijmen and Joan Daemen. So the standard wears a bureaucratic name while the algorithm underneath quietly carries its creators'. Our client-side encryption uses AES-GCM; the GCM part ("Galois/Counter Mode") also detects tampering, so a modified ciphertext fails to decrypt instead of silently lying.
• HKDF: "HMAC-based Key Derivation Function." It takes one starting secret and stretches or splits it into one or more usable keys, using HMAC (a keyed hashing step) as its engine. The name simply lists its parts. We use it in sealed identity to derive keys from the entropy in a user's PIN or recovery phrase.

Our codebase

The Lantern metaphor runs through the naming. These are the evident stories; Mechelle, drop the canonical founder's version over any of them when you have a minute.

• Lantern: the product. You "light a lantern" at a venue to put out a warm, visible signal that you are around and open to meeting people. A lantern is a gentle beacon, not a billboard, which is the whole tone of the app.

• lanterns (collection): active check-ins, the lit signals themselves (48-hour TTL).

• waves (collection): meeting requests. A wave is the lowest-pressure way to say hello: friendly, optional, easy to not see.

• frens: the affectionate internet-culture spelling of "friends." The misspelling is the point; it signals warmth and low stakes over a formal "connections" label.

• beacon (LanternBeacon): the lit signal made visible in the UI. A beacon is a light meant to be seen from a distance.

• dotfiles (the leading . on .agents, .claude, .env): a file whose name starts with a dot is hidden by default, and that started as a plain accident. Every folder quietly holds two little bookkeeping markers ("this folder" and "the one above it"), and an early tool for listing files wanted to keep those two out of sight. Instead of hiding just them, its author took the lazy route and hid anything starting with a dot. It stuck. Ever since, programs tuck their settings into dot-named files to stay tidy and out of the way, a whole habit grown from one shortcut nobody meant as a feature.

• VAPID (the "Web Push certificate" key pair behind our notifications): the acronym is Voluntary Application Server Identification. When your phone gets a Lantern push, the message doesn't travel from our servers straight to you; it goes through a relay run by your browser's maker. VAPID is the ID badge our side shows that relay: a matched pair of keys where the public half rides along in every browser (that's the one committed in our config, safe to share) and the private half signs each push so the relay knows it really came from us. The funny part of the name is the V: identifying yourself was proposed as voluntary, a courtesy, because the spec authors could not force anyone to do it. The relays then simply refused to deliver for servers that stayed anonymous, so the "voluntary" part is now mandatory everywhere while the name still politely pretends otherwise.

• Idempotent (why tapping "accept" twice can't create two chats): an operation is idempotent when doing it again changes nothing more, like pressing an elevator call button five times still summons one elevator. The word was coined in 1870 by the American mathematician Benjamin Peirce from Latin idem ("the same") plus potens ("power"): a thing whose square equals itself, literally "same-powered." Engineers borrowed it because networks are flaky and retries are everywhere, so the safest actions are the ones you can repeat without fear. Our wave accept is idempotent on purpose: a double-tap or a retried request finds the connection that already exists and hands it back instead of minting a twin.

• -compat (the suffix on packages like @firebase/database-compat): short for "compatibility layer," a small adapter that lets old code keep working after a library changes shape, like the plug adapter you keep in a drawer after moving countries: the walls changed, your appliances didn't. When Firebase rewrote its SDK into the modern modular style, it shipped -compat packages so code written the old way (firebase.database()) kept running unchanged, a convention seen across the JavaScript world whenever a library breaks with its past but leaves a bridge behind. The irony from our own history: one afternoon the compatibility package was the thing that broke our deploys, when an update started asking for a helper package that wasn't installed. The bridge briefly forgot its own job.

• Console (the browser tab where our lantern.* dev commands live): before it was a software window, a console was a physical desk. "Console" is French for a wall bracket, the carved support piece holding up a shelf, and organ builders borrowed it for the cabinet holding all of an organ's keyboards and stops: the one piece of furniture from which the whole instrument is played. Early mainframe rooms kept that meaning exactly, calling the operator's desk of switches and blinking lamps "the console" because it was the seat of control over a machine that filled the room. When computers shrank, the name stuck to whatever surface you command the machine from: the terminal, the game console, and eventually the browser's console tab, which is still just the operator's desk, miniaturized into a panel where you type instructions straight to the running app.

• YAGNI ("You Aren't Gonna Need It", now baked into our new tdd and code-review-rigor skills): a battle cry from Extreme Programming, the late-1990s methodology built by Kent Beck and friends on a Chrysler payroll project. The rule: build what today's requirement needs, not what tomorrow's might, because "might need it later" usually means paying now for a thing that never gets used, like buying ski boots for a trip you haven't planned in a size you're guessing your kids will be. The deliberately folksy contraction is part of the design: it's meant to be said out loud in a code review, and it is easier to wave off speculative machinery with a grin and five letters than with a lecture about carrying costs.

• Playwright (the tool that drives our headless browser tests): named for the theater, not the web. A playwright is the person who writes a play, and the framework leans all the way into that metaphor: you script actors (browser pages) through scenes (test steps), directing a performance rather than poking at a browser. It is Microsoft's successor to Google's Puppeteer (puppets on strings, same idea, different stagecraft), built by many of the same people. The spelling trips everyone up, because "wright" means a maker or builder (as in wheelwright or shipwright), not "write," so a playwright literally "builds" plays. Our two-account block-and-block test is exactly that: two browsers cast as two strangers, walked through a whole meet-then-block scene on the live dev stage.

• Teleport (our lantern.spoof.location.teleport() dev command): the word is a 1931 coinage by Charles Fort, a writer who collected newspaper reports of things science couldn't yet explain (his name also gave us "Fortean" for that whole genre). He glued Greek tele (far, as in telephone and television) onto Latin portare (to carry, as in portable and porter), so it literally means "to carry far." Purists note it's a Greek-Latin hybrid, which classical wordsmiths considered cheating; sci-fi didn't care and neither do we. Our version carries your fake GPS pin to the nearest venue so you can test check-ins without leaving the couch, which is about as close to the real thing as physics currently allows.

• Smoke test (what our new story checks do: render every Storybook story and fail if one blows up): borrowed from hardware workshops. When you finished wiring a circuit or fixing a pipe organ, the first check was to power it on and literally watch for smoke; no smoke meant it was safe to test properly. Plumbers did it even earlier, blowing actual smoke into pipes to find leaks. Software kept the name for the same idea: the cheapest possible "does it even turn on" pass that runs before any deeper testing is worth your time.

• Canary (our verifyEncryptionCanary check, which confirms your key still decrypts before touching real data): from the canary in the coal mine. Miners carried the small bird underground because it succumbed to carbon monoxide long before humans felt anything, so a quiet canary meant get out NOW. Ours is a tiny encrypted value we try to decrypt first; if it fails, we stop before any real data gets written wrong. Same job as the bird: a small, cheap life that raises the alarm early.

• kanban (the card-per-task board style we informally run our sessions and worktrees like): Japanese for "signboard," borrowed from Toyota's factory floor in the 1950s. Workers pulled a physical card off a bin when parts ran low, and the card itself traveled upstream as the order to make more. The insight was that the card is the work item: nothing gets built without a card, and the number of cards in motion is capped, so the floor never drowns in half-finished work. Software teams kept the name and the two rules (visualize the work, limit work in progress) and swapped the parts bins for sticky notes.

• tmux (the tool that keeps our dev-VM sessions alive when a phone connection drops): short for terminal multiplexer, and "multiplexer" is borrowed from old telephone engineering, where one physical wire was made to carry many conversations at once. tmux does the same trick with a terminal: one connection into the machine fans out into many live sessions inside it. The part that makes it beloved is the inverse: hang up the phone line and the conversations inside keep going without you, waiting for you to reconnect and pick up where they left off.

• go-links (the go/ shortlink pattern behind our planned intranet links, #811): born at Google in the mid-2000s as an internal service where typing go/ plus a word in the browser jumped straight to a tool or doc. The genius was making links speakable: you could say "go slash payroll" in a hallway and everyone could type it from memory, no bookmark, no search. The pattern escaped into the wider industry through ex-Googlers who missed it so much they rebuilt it at every new company, and today "go-links" is the generic name for any internal shortlink service, whoever hosts it.

• bootstrap (as in our npm run env:bootstrap, the command that pulls a new developer's secrets down in one go): from the tall boots people used to yank on by the little loops at the back, called bootstraps. "To pull yourself up by your bootstraps" started in the 1800s as a joke about something physically impossible, since you cannot lift yourself off the ground by tugging your own boots. Engineers loved the paradox and kept the word for any process that somehow starts itself from nothing: a computer "boots" (same word, shortened) because a tiny program loads a slightly bigger one that loads the whole operating system. Our version is friendlier than the paradox suggests: one command takes a brand-new machine with no credentials and leaves it fully set up.

• askpass (the little go-between that decides whether a terminal git command can reuse your VS Code GitHub login): named for its entire job description, "ask for a pass(word)". It began as ssh-askpass in the 1990s: when SSH needed a password but had no terminal to ask in (say, a graphical app launched from a desktop icon), it spawned this tiny helper to pop up a box and ask on its behalf. Git kept the idea and the name: it will delegate its "please log in" moment to any helper program you point it at. VS Code uses exactly that trick inside its own integrated terminal, quietly pointing git back at itself, so git there already knows who you are. The same command in a plain outside shell has no go-between, so it asks you to sign in fresh even though VS Code is logged in two windows away.

• Homebrew (the Mac package manager our docs mention for installing tools like gh): named after beer brewed at home, because that is what it does with software: instead of buying it "bottled" from a store, your own machine brews it fresh from a recipe. The beer metaphor runs through the whole tool: install recipes are "formulae", installed software ages in the "Cellar" in "kegs", third-party recipe collections are "taps", and prebuilt downloads are, naturally, "bottles". Its creator, Max Howell, is also known for a legendary tweet: Google turned him down in a job interview for missing a whiteboard puzzle, even though most of their engineers were using his software daily.

• npm and nvm (the near-twin commands in our setup docs): nvm is the straightforward one, literally "Node Version Manager", the tool that installs and switches Node versions. npm, Node's package manager, is the joke: its own FAQ long insisted that npm is NOT an acronym, and that the name is really a recursive abbreviation for "npm is not an acronym", a gag in the tradition of GNU ("GNU's Not Unix"), where a name contains itself forever like two mirrors facing each other. Everyone reads it as "Node Package Manager" anyway, and the tool does not seem to mind. The tell worth remembering: nvm gets you Node, and npm comes riding along inside Node, so you never install npm itself.

• zsh (the default shell on every modern Mac, and the reason a pasted "comment" once tried to npm-install a package named "#"): not an acronym at all. Paul Falstad wrote the shell as a Princeton student in 1990 and named it after the login ID of his teaching assistant, Zhong Shao, whose username was simply "zsh". Falstad thought it made a great name for a shell, and Shao, who went on to become a Yale computer science professor, has been immortalized in millions of terminal prompts ever since. A practical footnote our onboarding learned the hard way: unlike bash, zsh does not treat "#" as a comment when you paste commands interactively, so annotated command snippets that work fine on Linux misfire on a Mac.

• "Onboarding" (the whole thing this checklist is for): the word is borrowed straight from ships. To come "on board" was to step onto a vessel, and someone who joined a crew was taken on board with them. Corporate HR picked the phrase up in the 1970s for the same idea: the person is not just hired, they have to actually get on the boat, learn where everything is, and become part of the crew before the trip counts as started. It is a better metaphor than it looks, because it says the finish line is not the paperwork, it is the newcomer being genuinely aboard and useful. Which is why a good onboarding page ends with "here is what to do first," not "setup complete."

• WYSIWYG (the "what you see is what you get" style of editor we may someday put on the docs site, where the page looks the same while you edit it as it will when published): the phrase was a comedy catchphrase before it was a computer term. Comedian Flip Wilson's character Geraldine made "what you see is what you get!" famous on early-1970s American TV, and word processing folks borrowed it for the first editors whose screens finally matched the printed page. That was a genuine novelty at the time: editing normally meant typing cryptic formatting codes and praying the printout looked right, like decorating a cake blindfolded and only seeing it at the party. The name stuck because it names the promise, not the mechanism: no surprises between the screen and the final thing.

• snake_case, kebab-case, and camelCase (why lantern_app and the renamed lantern_context use underscores while branch names like docs/onboarding-fixes use hyphens): programmers needed nicknames for their word-joining styles, and all of them are pure visual jokes. Words_joined_by_underscores hug the ground like a snake. Words-joined-by-hyphens look like chunks skewered on a stick, a joke coined on a programming Q&A site in the early 2010s that stuck. wordsThatBumpUpward are camelCase because the capitals look like a camel's humps; start with a capital too, LikeThis, and it gets called PascalCase instead. None of these were ever official standards; they are playground nicknames that won because they make you see the shape instantly.

• oklch (the colour format all our Tailwind colours are written in, e.g. oklch(70.7% 0.022 261.325)): three ideas bolted together. The L, C and H are lightness, chroma (how vivid) and hue (which colour), which is a far friendlier set of dials than red/green/blue: to make a colour paler you turn one knob instead of guessing at three. The "ok" is the fun part. In 2020 a Swedish engineer, Björn Ottosson, published an improved version of an older colour space called Lab and, rather than naming it after himself or slapping a version number on it, called it Oklab: "OK" as in good enough, fine, this works. It is one of the rare pieces of technical naming that is quietly modest. The practical payoff for us: in oklch, two colours with the same L genuinely look equally bright, which older formats get badly wrong, so a palette built on it stays even-toned across every hue.

• accent-color (the one CSS property that makes a browser checkbox match our amber instead of its default blue): "accent" here is the design sense, the single highlight colour a layout uses to draw your eye, everything else kept quiet. That traces back to Latin accentus, "a song added to speech", the mark showing which syllable you stress when speaking. The instinct is the same in both: the surroundings stay even and exactly one thing is deliberately raised. Worth knowing because a checkbox is drawn by the operating system, not by us, so ordinary styling slides off it; accent-color is the browser offering us one knob on something we otherwise cannot reach.

Boilerplate

What it is: text you reuse without rewriting it, like the standard clauses in a contract or the header every one of our files carries.

In the 1800s, syndicated stories and ads were shipped to small newspapers as ready-made metal printing plates. A local editor could not edit them, only drop them in whole. The plates looked like the thick steel used to build steam boilers, so printers called them boiler plate. The name kept the important part of the meaning: not just "reused text" but text you receive as a solid block and cannot cut.

Rubber duck debugging

What it is: explaining your problem out loud, step by step, to something that cannot help you. Halfway through the explanation you usually spot the answer yourself.

The name comes from a story in The Pragmatic Programmer (1999), where a programmer carried an actual rubber duck and forced himself to walk it through his code line by line before asking a colleague. It works because talking to a person lets you skip the parts you assume are fine, and those are where the bug lives. A duck does not nod along, so you have to say all of it.

Lint

What it is: a program that reads your code or your writing and complains about the small stuff before a human has to. Ours check for things like em dashes, missing Storybook stories, and secrets pasted where they should not be.

Doug McIlroy wrote the first one at Bell Labs in 1978 and named it after the lint trap in a clothes dryer: the fuzz that comes off in normal use, that nobody notices until you collect it in one place and look at the pile. The name is doing real work. It says up front that a linter is not looking for the bug that breaks your program. It is looking for the fluff, and the argument for bothering is that fluff accumulates.

Observability

What it is: being able to work out what is going wrong inside a running system just by looking at what it emits from the outside: its logs, its numbers, its error reports. It is the difference between "the site feels slow" and "the venue lookup is waiting on a database that is out of connections."

Rudolf Kalman defined the word in 1960, and not for software at all. He was doing control theory, the mathematics of steering things like aircraft and chemical plants, and he needed a precise way to ask a question: given only the readings coming off this system, can I actually determine what state it is in? If yes, the system is observable. If no, no amount of staring at the dials will tell you, because the information simply is not in them.

The borrowed name carries the useful part. It frames the goal as a property of the system rather than a property of your dashboard. Adding more charts does not make something observable; emitting the right things does. A system that never records which venue a request was for cannot answer "which venue is slow", however many screens you point at it.

The medical cousin is worth knowing too. The four measurements most teams watch first (how long requests take, how many arrive, how many fail, and how full the fullest resource is) are called the golden signals, named for vital signs: the pulse and temperature a doctor takes before ordering anything more elaborate.

• amber (the caution colour in our status scale, --warning: #f59e0b, the one that tells you something is degraded rather than broken): amber is the honey coloured fossil resin, tree sap that hardened over millions of years, the stuff that sometimes traps an insect mid-step. The name took a wrong turn to get here. It comes from Arabic anbar, which meant ambergris, a waxy substance that washes up on beaches and was prized in perfume. Both things drifted ashore, both were rare and valuable, and European traders muddled the two until the name stuck to the resin instead. So the colour is named after a substance it was never made of. It reached traffic lights by way of railway signalling: early signals used red for stop, white for clear and green for caution, until a red lens fell out of a lamp and left a plain white light, which a driver correctly read as "go". Green was promoted to go, and caution needed a new colour. Amber got the middle job and has kept it ever since, which is why a dashboard warning is amber and a dashboard error is red. Worth knowing because it explains why amber cannot also be a link colour: the whole point of the middle light is that it means one thing.

• mulberry32 (the tiny random-number generator our ad-network seed script uses so its "random" numbers come out the same every run): a pseudo-random generator is a recipe that turns one starting number into an endless stream of numbers that look random but are perfectly repeatable, like shuffling a deck the exact same way every time. Handy for test data: re-running the seed produces identical charts instead of new noise. The name is half botany, half bookkeeping. Its author, Tommy Ettinger, named his little family of generators after trees (this one the mulberry), and the 32 says it works in 32-bit numbers, the small integer size every browser handles quickly. He published it free for anyone to use, and its whole engine fits in four lines, which is why it shows up in games, art sketches, and seed scripts instead of heavyweight libraries.

• candela (the official scientific unit for how bright a light source is, and the code name for Lantern's 1.0 release): it is Latin for "candle", and that is no coincidence. Before electricity, brightness was measured against a real standard candle made to a recipe, so lamps were rated in "candlepower" the way engines are rated in horsepower. When scientists later needed an exact, repeatable definition, they kept both the idea and the name: one candela is still about the brightness of one ordinary candle. The modern, precise thing is named for the little flame it replaced, which is a rather fitting story for a lantern app.