Open-Source Web3 Project

A contributor server for an open-source protocol codebase: RFCs, good first issues, maintainer calls and grant work.

  • 6 categories
  • 23 channels
  • 10 roles
  • Medium
Download Discord JSON

Choose a server, review what will be created or reused, then confirm. Merge keeps what you have; replace rebuilds the server. Vetox takes a safety backup first either way.

No uses yetNo views yet

Server structure

Channels

START HERE

  • contributing-rules

    How to contribute, and what this server is not for. No price talk.

  • general

    Everything else.

  • your-area

    Self-Roles panel.

  • announcements

    Releases, RFC decisions, calls.

CONTRIBUTING

  • good-first-issues

    Curated and confirmed current. If one is stale, say so in help.

  • claim-an-issue

    Say what you are taking, so nobody duplicates it.

  • contributing-help

    Stuck on setup or scope? Ask here.

  • commits-and-releases

    Automated from the repository.

RFCS

  • rfc-drafts

    Proposals in progress.

  • rfc-discussion

    Argue here, not in the draft.

  • accepted-rfcs

    The permanent record of why the project is the way it is.

DEVELOPMENT

  • core

    The protocol itself.

  • tooling

    Build, deploy, developer experience.

  • clients

    Libraries and interfaces.

  • testing

    Suites, fuzzing, coverage.

  • maintainer-calls

    Agendas and notes, published so outside contributors are not second-class.

  • Maintainer Call
  • Pairing Room

GRANTS AND FUNDING

  • grant-opportunities

    What is open, and by when.

  • grant-applications

    Written in public. Scope and cost.

  • funded-work

    Progress reports. Funded work reports where the ecosystem can see it.

SECURITY

  • security-policy

    How to report privately, what happens next, and what never goes public first.

  • advisories

    Published after a fix ships.

Roles

  • MaintainerAdministrator
  • ReviewerAdministrator
  • ModeratorModerator
  • Contributor
  • Grantee
  • Core
  • Tooling
  • Clients
  • Muted

Overview

For a codebase with outside contributors, where the hard problem is not attracting them but keeping them. #good-first-issues is read-only and curated, holding only issues a maintainer has actually confirmed are self-contained and currently accurate, because the fastest way to lose a first-time contributor is a starter issue that turns out to need three days of context. #contributing-help is where they ask, and #claim-an-issue prevents two people silently doing the same work. RFCs is how design happens in the open: #rfc-drafts for proposals in progress, #rfc-discussion, and #accepted-rfcs as a read-only record, so the reasoning behind an architectural decision survives the people who made it. Development splits by area — #core, #tooling, #clients and #testing — and #maintainer-calls carries agendas and notes, published so contributors outside the call are not second-class. Grants and Funding is the part specific to this ecosystem: #grant-opportunities, #grant-applications where teams write in public, and #funded-work with progress reports, because grant work done privately is how an ecosystem loses track of what it paid for. Security has its own boundary: #security-policy states how to report privately and what never to post publicly. Nothing here discusses price, and the rules say so plainly.

When to use it

Open-source projects in this ecosystem attract drive-by contributors and lose them: the starter issues are stale, two people do the same work, design decisions happen in a call nobody outside heard, and grant-funded work disappears into private repositories. This layout curates first issues, has contributors claim work, keeps design in public RFCs with a permanent record, and requires funded work to report progress where the ecosystem can see it.

What makes it different

  • Good first issues are curated and confirmed current, which is what retains a first contributor.
  • Issues are claimed in public, so two people never silently build the same thing.
  • Accepted RFCs are a permanent record, so architectural reasoning outlives its authors.
  • Grant-funded work reports progress publicly rather than disappearing into a private repository.

Recommended Vetox setup

  • Notifications

    Point Notifications at the repository so #commits-and-releases fills without a maintainer relaying every merge.

  • Self-Roles

    Post a Self-Roles panel in #your-area so an RFC in tooling pings the people who work on tooling.

  • Tickets

    Point Tickets at #security-policy so a vulnerability report reaches maintainers privately rather than in public.

  • Auto-Mod

    Run Auto-Mod across public channels, since open-source project servers attract impersonation and fake-airdrop links.

Questions

Why curate good first issues so tightly?

Because the first issue determines whether someone ever submits a second. An issue that looks self-contained and turns out to require understanding three subsystems does not just cost that contributor a weekend, it convinces them the project is hostile. A maintainer confirming that an issue is genuinely scoped and still accurate takes minutes and is the highest-return work in open-source community building.

Should RFC discussion really be public?

Yes, and the accepted record more so. A protocol's architecture outlives its current maintainers, and the question that arrives in two years is always why it was done this way rather than the obvious alternative. An accepted-RFC channel answers that without anyone having to remember. It also means a contributor can disagree with a decision by reading the reasoning rather than by guessing at it.

What belongs in the security policy channel?

How to report privately, what will happen after a report, roughly how long a response takes, and an explicit statement that vulnerabilities are never to be posted publicly first. Projects without this get one of two failures: a researcher posts publicly because they had no other route, or a real report sits unread in a general channel for a fortnight.

Common mistakes

  • Labelling stale issues as good first issues, which loses a first-time contributor on day one.
  • Making design decisions in a maintainer call with no written record, excluding every outside contributor.
  • Letting grant-funded work report privately, so the ecosystem cannot tell what it actually paid for.

Consider instead

Do you have any doubts?

Our team is there for you

0.0k

Servers

0+

Commands

0

Users

0

Languages