Communities · Open Source
Support channels for your project, minus the noise.
Give your users a place to ask questions, report bugs, and follow releases, while maintainers keep their sanity. Your community joins with one link, in the browser, with nothing to install.
What your project gets on day one.
The tools a support community actually needs, built in from the start instead of bolted on later.
Help channels that scale
Separate channels for install questions, bug reports, and general talk keep triage manageable as the project grows. Group them into categories so the sidebar still makes sense at channel twenty.
Release announcements
Announce releases where your users already are. Pin the migration notes so you only write them once, and lock the channel with permissions so announcements stay announcements.
Contributor roles
Maintainers, contributors, and users each get a visible role, so newcomers know who is speaking for the project. Answers from a maintainer read differently, and now they look different too.
Threads for the deep dives
A gnarly debugging session can run for forty messages. In a thread, it stays attached to the original question instead of drowning the channel, and everyone else can keep talking.
Pins and bookmarks
Pin the install guide, the rules, and the answer you have typed eleven times. Members bookmark the messages that solved their problem, so your best answers keep working after they scroll away.
Slow mode and filters
When a release breaks something, slow mode keeps the channel readable. Automated filters catch spam and link floods before a human has to, at three in the morning included.
Run it like you run the project.
In the open, with a record.
The audit log keeps moderation transparent, and slow mode keeps issue-day chaos survivable. Members can browse your public server before joining, the same way they read your code before installing it. A project that works in the open should not have to run its community as a black box.
Moderation with a paper trail
Every kick, ban, role change, and channel edit lands in the audit log with who did it and when. When you share moderation across time zones, that record is what keeps co-maintainers aligned: a disputed call becomes a log entry to read, not an argument to reconstruct from memory. The moderation tools are built for exactly this kind of shared, accountable operation.
Readable before joining, like your README
Nobody installs a dependency they cannot inspect. Your community works the same way: people can look at a public server before committing to it, and projects that opt in appear on the Explore page where users already searching for communities can find yours. The tone of your help channel is visible up front, which is the best recruiting pitch a healthy project has.
Built for the bad days
The day a release breaks, or the day you land on a front page, is the day chat earns its keep or falls over. Per-channel slow mode throttles the flood without silencing it. Automated filters absorb the spam wave that follows attention. Roles and permissions keep the announcement channel writable by maintainers only, so the one message everyone needs to see is not buried under two hundred replies to it. You configure all of this once, on a calm day, and it is simply there on the loud one.
From README to living community.
Five steps, one afternoon, no infrastructure. You run a project; you do not need to run a chat server too.
Create the server
Name it after the project, drop in your logo as the icon, and write a one-line description that says what the project does. The create-a-server guide walks through every field, but the whole thing takes about a minute.
Lay out channels, small at first
A proven starting blueprint: a Support category with an install-help and a bug-reports channel, a Development category with a contributors channel and a maintainer-only announcements channel, and one general channel for everything else. Resist making twelve channels on day one. Split a channel when it overflows, not before.
Set up the three roles
Maintainer, Contributor, User. Maintainers can post in announcements and moderate; contributors get a visible color so their answers carry weight; everyone else is a user by default. Per-server nicknames let people match their name here to their handle on your code host, which makes cross-referencing pull requests painless.
Put the invite in the README
One link is the whole onboarding. It goes in your README badge row, your docs footer, and your release notes. Because Vronify.chat runs in the browser with nothing to install, the distance between "reads your README" and "asks their question in your server" is a single click, and that distance is what decides whether a community forms at all.
Pin the essentials and open the doors
Pin the rules, the install guide, and a short "how to report a bug well" message in the channels where people will need them. Then list the server on Explore when you are ready for strangers. The owner handbook covers everything after that, from the first hundred members to the first moderation decision you would rather not make.
Chat and the issue tracker are different tools.
Projects that mix them up get chaos in both. Here is the division of labor that works.
The rule of thumb: chat is where things move, the tracker is where things live. A decision that exists only in scrollback is a decision you will make twice.
Infrastructure your project does not have to run.
We build the way you do: hand-written from 0 to over 125.000 lines of code, no template underneath, running on hardware we own and tune ourselves.
Your community's data, handled the way you would handle it.
Open source people read the license before they depend on something. Here is ours in plain words.
Vronify.chat is built in the Netherlands by a small team, and the platform is not a white-label or a template with a new coat of paint. That matters here because the promises below are ours to keep: nobody upstream of us can change the terms of your community's data. The full picture is on the privacy page, but these are the parts an open source community should weigh before moving in.
What we read and what we don't
Direct messages are private. We don't read them, and in the app only the people in the conversation can see them. Community channels are visible to their community and its moderators, and we say so plainly: your moderators need to be able to see public spaces to keep them safe, and pretending otherwise would be dishonest. What we never do, in either case, is sell data, show ads, read private conversations, or hold your data hostage.
Bans that do not confiscate accounts
Moderation on most platforms is entangled with account destruction. Here they are separate: a ban only stops participation in that community. The banned person keeps their account, every message they ever sent, and the DMs they received, unless the sender removed them. For a project community this cuts both ways, and both ways are good. Your moderators can act decisively without acting as executioners, and your members know that joining your server never puts their account at someone else's mercy. Anyone can export their data at any time, and delete their account whenever they want, which anonymizes it.
Nothing watching your members
There are zero trackers, zero ads, and zero data brokers on the platform. If your project attracts privacy-conscious users, and open source projects usually do, you are not asking them to trade surveillance for support when you send them to your server. The security page covers how the platform itself is defended, and the vulnerability disclosure policy explains how to report anything you find in ours, because we accept bug reports the same way you do.
Here today, and on the roadmap.
Everything on the left ships with every server right now. Everything on the right is coming, and none of it will cost you a rebuild.
Available today
- Real-time messaging with edits, replies, reactions, and read receipts
- Voice channels for pairing sessions, office hours, and release-day standups
- Threads, pinned messages, polls, and bookmarks
- Roles, permissions, audit log, slow mode, and automated filters
- Custom emoji, server tags, categories, and per-server nicknames
- Browser-first with nothing to install, and one-link invites
Coming soon
- The bot engine: welcome cards for first-time contributors, custom commands for the questions you answer daily, reaction roles, leveling, and tickets for private reports
- A mobile app for iOS and Android, for the maintainer who triages from the train
- A desktop app for Windows, macOS, and Linux, and yes, Linux is not an afterthought
- Everything else lands in the changelog as it ships, with no reconfiguration on your side
Questions maintainers actually ask.
Do my users have to install anything to join?
No. Vronify.chat is browser-first: the invite link in your README opens the server directly, and creating an account takes moments. That is the whole funnel. For a project community, where every extra step between "I have a question" and "I asked it" loses people, this is the single most important property of the platform. Mobile and desktop apps are coming, but nobody will ever need them to participate.
What does it cost the project?
Nothing, and that is not a trial. Core features are free forever, with optional extras for power users planned later and no surprise paywalls. There is also no infrastructure bill hiding behind the free tier: you are not hosting anything, patching anything, or keeping anything online. Your community runs on our hardware, which we own and tune ourselves.
Can this hold up when the project gets big?
A single server supports more than 50,000 members, message delivery stays under 40ms median in Europe, and the platform has held 99.9% uptime across the last 12 months. The performance page has the details. The practical answer for maintainers: the ceiling is far above the point where your bottleneck becomes moderation attention rather than infrastructure, and the moderation tools are built for delegating exactly that.
How do we stop chat from swallowing the issue tracker?
By deciding the division of labor up front and pinning it. The pattern that works: bug-reports in chat is for triage, and anything confirmed gets written up as a real issue with a link back. Post the expectation in the channel description, and have contributors model it. Chat lowers the barrier for reports you would otherwise never hear about; the tracker keeps the ones that matter. You want both, doing different jobs.
What happens when we have to ban someone?
The ban removes them from your community, and that is all it does. They keep their account, their message history, and the DMs they received. Every moderation action is recorded in the audit log, so your co-maintainers can review the call, and the moderation guide covers how to make those calls consistently. Separating "removed from this community" from "losing their account" makes bans easier to issue when they are warranted and easier to defend afterwards.
Can contributors run bots or integrations?
Not third-party ones, by design: no external code runs inside servers, which is part of how the privacy promises stay honest. Automation comes from the built-in bot engine, which is coming soon and covers the common cases directly: welcome cards, custom commands for recurring answers, reaction roles, leveling, a message log, and tickets. It is one switch in server settings when it arrives, with no hosting and no tokens. If it is missing something your workflow needs, tell us.
How do people find the community?
Two routes. The one you control: the invite link in your README, docs, and release notes, which is where most members will come from. And the one that compounds: listing your server on the Explore page, where people browsing public servers can read your community before joining it. Server tags help the right people recognize the project at a glance.
Your community. Your rules. Your data.
Create a server, invite your people, and see what chat feels like when your account actually belongs to you.
Free to start. Live in under a minute. No install required.