Tagline
The group chat for the metro platform, the campus walk, or the line outside a party. Open the app, get a random name, and talk with the people around you—no friend lists, channels, or saved history.
Inspiration
Every chat app starts by asking who you already know: add a friend, join a server, share a number. But a lot of the moments when you most want to talk are with people you don't know yet and are standing right next to: the line for the light show, the lecture hall before the exam, the bus stop when the bus is late.
So we asked what a chat would look like with no friends list and no channels at all. That is Blip: you open it, and you are in a room with the people physically around you. Walk somewhere else, and you are with whoever is there. It is for people from 14 to 22, people in school, and it stays light on purpose: that one idea is the whole product, and every feature has to make it better or clearer.
What it does
Blip puts you in a chat room with the people physically around you, and nothing else.
- Rooms form from where people are. Nobody types a name, picks a room or adds a contact. People within about 50 m of each other chain together, and any chain of two or more is a room. A crowd of 200 is one room.
- Rooms are never wider than 1 km. When a room's people spread further apart than that, it parts, and the side with more than half of the open apps keeps the room and its conversation.
- Lone people look further. Someone with nobody that close searches outward, up to about 1 km, and joins the nearest room or pairs up with another lone person.
- A made-up name in every room. The server gives each person a two-word name such as "Mellow Otter", different from everyone else's in the room and new in every room. You can ask for another one a few times.
- Chat with the room. You see only what is said while you are there. Nothing is kept on the server.
- Rooms follow their people. When a group walks off together it keeps its chat. When two rooms meet, the older room carries on and the conversations join: everyone keeps what is on their screen, with one line marking the moment ("Your room joined an older room.").
- Polls. Anyone can ask the room a quick question. A line in the chat tells everyone who asked and what; tap it to vote. Votes are counted and never attributed.
- A personal word filter. Each person can hide the words on a list of 263 in what they read. It changes only their own screen.
- A send limit, so that one person cannot flood a room.
- A bad position is no position. If the phone itself says its position is rougher than 500 m, Blip does not use it to place you, and if you allowed only approximate location, it tells you to allow precise location.
- Nobody is shown where anyone is. In the members list, Blip tells you roughly how far your room reaches, rounded up to 50 m, and nothing about any one person.
- A look of our own, called Lineage. The conversation is drawn along one line, with a top bar for the room's age, your name and keys to the members and the polls, a writing box with a status strip under it, sheets for the members and for your name, and pages of their own for when you have no room: looking, no position, location refused, and nobody near.
How we built it
Blip is one TypeScript repository in strict mode, with npm workspaces:
packages/shared: the wire protocol (every message is a Zod schema), the distance function, and the room calculation. It is pure: no platform, no I/O, no clock, so the same code runs on the server, in tests, and in a browser sandbox of draggable dots.apps/server: a small Node.js server on Socket.IO. It holds who is where, recalculates the rooms every 5 seconds, and routes chat. All state is in memory.apps/mobile: an Expo (React Native) app with Expo Router. It runs inside Expo Go on a phone and as a web build. Blip's logo is its app icon, the web page's icon, and a mark on the pages with no room.apps/sandbox: a Vite page that runs the same clustering calculation on dots you drag around.
The distance between two reported positions is the haversine distance:
$$d(a,b) = 2R \arcsin \sqrt{\sin^2!\frac{\varphi_b-\varphi_a}{2} + \cos\varphi_a \cos\varphi_b \,\sin^2!\frac{\lambda_b-\lambda_a}{2}}$$
where \(\varphi\) is latitude, \(\lambda\) is longitude (both in radians), and \(R = 6{,}371\ \text{km}\) is the Earth's mean radius.
Two people are linked when \(d(i,j) \le 50\ \text{m}\), and the rooms are the connected sets of that graph with at least two people. A person counts for 30 minutes after their last report, and a reading the phone itself says is rougher than 500 m is not a report.
No room may be wider than 1 km:
$$\max_{i,j \in R}\; d(i,j) \le 1000\ \text{m}$$
When two members drift past that, the room parts about a minute later. A room stops taking people a little under the limit, at 900 m, so that a position that jitters at the edge does not keep putting someone out and back.
Positions are noisy, so rooms must not shuffle every time a reading jumps. A change of room has to hold for about a minute before it happens, and a group \(G\) keeps a room \(R\) only if it holds most of the room's people with the app open:
$$|G \cap R_{\text{open}}| > \tfrac{1}{2}\,|R_{\text{open}}|$$
where \(R_{\text{open}}\) is the room's members with the app open (or all its members, if nobody has it open).
When a room parts into two exact halves, neither has a majority, so one half is picked by a hash nobody can predict. Each open-app member \(u\) gets a score from the server's secret seed, the room and their own id, and the half that holds the lowest score keeps the room:
$$k = \arg\min_{u \in R_{\text{open}}}\; h(\text{seed},\, R,\, u)$$
Blip was built during the hackathon, mostly by AI agents working from feature specs that the team wrote. Each change was built on its own branch, checked by one gate (npm run check: types, lint, format, tests, and both bundles), and reviewed by a second model that only reads; each whole feature landed only after a person on the team approved it. The one exception was the last step before submission, switching the app's main page to the new look, which landed without a second review for lack of time and was checked in browser tabs and then on our own phones instead. By the first submission the gate ran 1,394 tests; it now runs 2,463.
Challenges we ran into
- Rooms that feel stable. The first version moved people the instant the map changed. Making a room follow the majority of its people, wait a minute before any change, and survive a merge with its conversation intact took several designs, each checked against the code before it was built.
- A limit on a room's width. "Rooms can't be wider than 1 km" sounds simple, but someone has to leave when a room gets too wide, and every answer has a cost: a person who did not move can lose their conversation, and a fake position could be used to push someone out. The design went through five versions before it was built, and the side with most of the open apps keeps the room.
- Privacy. A distance to one person, even a rounded one, can be used to find them by walking around and watching it change. So the app never says how far away, or which way, any person is, and the room's size is worked out through coarse squares. We also wrote down what is still not solved: someone with a modified app could work out where a member is from who shares a room, which has to be settled before strangers use it.
- Android would not give us a position. On Android emulators the app said it could not find its position although the device had one. We added diagnostics before changing anything, and they showed the cause: asked for a rough position, Android never switched GPS on while its network location was off. The app now asks the sharper way in exactly that case.
- The first iPhone could not reach the server. The app loaded on an iPhone and said "No connection to the server." The logs showed the server was listening only on the laptop itself, so no phone could reach it. Restarted on the address the phone could see, it connected two seconds later.
- No Mac. We built and checked a phone app from Windows machines, so everything runs inside Expo Go and as a web build.
- Many agents on one machine. Several builders worked at once, each in its own checkout with its own ports, and a few shared files could be changed by only one branch at a time. We also learned that tests written by the builder often pass with the rule they name broken; the second reviewer caught those before they landed.
Accomplishments that we're proud of
- The core idea works end to end on real phones: three or more phones in one room, each with its own name, chatting within seconds of opening the app.
- Two rooms that meet become one, and nobody loses the conversation on their screen.
- It runs on real phones in Expo Go, as well as on two Android emulators and in the browser.
- A design language of our own, called Lineage, drawn and measured through three rounds, and now the room page itself.
- An honest record: every decision, who made it and when, and every known gap.
What we learned
- The hard part of a location app is not finding people; it is deciding when not to move them.
- "What does this reveal about where a person is?" has to be asked of every feature, including the ones that look harmless.
- Confirm the cause before fixing: our worst bugs, from Android's missing position to the iPhone that could not connect, were found by reading a log, not by guessing.
- Writing a feature as a short spec, with its cases and a cut line, is what let a small team and many agents work at the same time.
What's next for Blip
- Finishing Lineage: the room page is in; the rest of the app still has its plain first look.
- A real crowd: we have had three or more phones in one room; next is the dozens of people Blip is made for, all in one place.
- A points economy, a little like Twitch bits: everyone gets points to spend on what a room does together (1,000 to start and 200 a day, as first drafted). Points can never be bought or cashed out; they change hands only through the room's games.
- Games for the room, played for points or just for fun: two-player games starting with chess, a blackjack table, and betting points on how a room's poll will turn out.
- Leaderboards and badges you opt into: by default you stay anonymous and new in every room; switch it on and your badges follow you, and a board shows the top players by rough tier, never an exact score.
- Voice memos: a first recording trial is in, for the team's development builds only.
- Room names, a way to pause being placed, a board of the oldest rooms, and reporting.
- Before strangers use it: forming rooms in a way that cannot give away where a member is.
Built with
Built With
- android
- android-emulator
- async-storage
- eslint
- expo-go
- expo-location
- expo-router
- expo.io
- gps
- ios
- javascript
- metro
- node.js
- npm-workspaces
- prettier
- react
- react-native
- react-native-web
- socket.io
- typescript
- vite
- vitest
- web
- websockets
- zod