Valour is a free, open source community platforms project written in C# and released under AGPL-3.0. It has 397 GitHub stars, 39 forks and 88 open issues, and was last pushed 8 days ago. On this registry it ranks #14 of 14 tracked projects in Community Platforms, with 5 head-to-head comparisons available. It gained 1 stars over the last 6 tracked days.

What is Valour?

Valour is an open-source community platform written in C# and .NET with a Blazor client, licensed AGPL-3.0, intended for people who want to run or join social communities — called planets — on infrastructure they control rather than on a vendor's servers.

What it is

Valour lives in the .NET ecosystem. The server exposes HTTP APIs and SignalR connections, the client is a shared Razor UI hosted either in the browser as WebAssembly (Valour/Client.Blazor) or as a native application (Valour/Client.Maui), and the repository is split into Config, Client, Sdk, Shared, Database, Server, Web, and Tests directories. Communities, or planets, can each carry chat channels, thread feeds, wikis, voice and video calls, roles, an economy, and a village where members walk around and meet. The client supports tabs, splits, and multiple open conversations at once, and bots consume the same SDK and API contracts as the client.

The concrete problem is that running a community normally means renting a closed hosted platform where the operator controls the account list, the data, and the terms. Valour gives an operator a Compose bundle that stands up an entire instance — application, PostgreSQL, Redis, Caddy, and filesystem media storage — on a domain they own, and it adds a federation path so that a hub can own accounts and the global planet registry while registered community nodes host planets on independent domains. A planet can be moved between nodes: the owner starts the move from the planet's Federation settings, imports the signed grant, verifies the destination, and finalizes source deletion.

Key capabilities

  • Planets as the unit of community, each supporting chat channels, thread feeds, wikis, voice and video calls, roles, an economy, and a walkable village.
  • A client with tabs, splits, and multiple open conversations, sharing one Razor UI across the Valour/Client.Blazor WebAssembly host and the Valour/Client.Maui native host.
  • Real-time transport over SignalR, with an API client, models, caches, and SignalR connections packaged in Valour/Sdk for both first-party clients and bots.
  • A root Docker Compose bundle containing Valour, PostgreSQL, Redis, Caddy, and filesystem media storage, with Caddy obtaining the HTTPS certificate and proxying the application.
  • Self-hosted voice through a LiveKit overlay, documented in Docs/Deployment/SelfHostVoice.md along with the required media ports.
  • Federation through a hub that owns accounts and the global planet registry, with nodes issuing destination-specific credentials so a client's normal Valour session token stays with the hub.
  • Persistence through Entity Framework models and migrations under Valour/Database.

Who uses it and how

  • Community operators who self-host the full Compose bundle, point a public domain at the host, and allow inbound ports 80 and 443.
  • Federation node operators who run ./scripts/valour-node-setup, which configures the domain and hub, creates a private Data Protection key, and asks which owners may move planets to that node, then register and verify the public node in the hub's User Settings, Federation screen.
  • Planet owners migrating an existing community between nodes, using signed grants and destination verification before source deletion.
  • Developers running local server work against PostgreSQL and Redis, JavaScript tests with Node.js, and browser tests with Playwright.
  • Bot authors who build against the same SDK and API contracts the official clients use.

Getting started

From the repository root, copy .env.example to .env, set the domain, database password, and bootstrap administrator credentials, then run docker compose up -d; a hosted instance is also available at app.valour.gg.

How it compares

No other products are named in the facts provided for this entry, so no licence, hosting, or cost comparison can be drawn from them. On the evidence available, Valour stands alone in this registry.

When to use it — and when not to

Expect to operate PostgreSQL, Redis, Caddy, and media storage yourself, to supply a domain with ports 80 and 443 open, and to add LiveKit if you want self-hosted voice; note also that the Compose file maps supported .env values into the container, and that adding an arbitrary setting to .env does not pass it to the application. Skip it if you want a managed service with no infrastructure to run, or if AGPL-3.0 obligations do not suit your plans. Contributing carries its own friction: the SDK is pinned in global.json to 11.0.100-preview.3.26207.106 with roll-forward disabled, and the repository carries 88 open issues against 397 stars.

project readme (upstream, from github) — read inline

Valour logo

Valour

Valour is an open-source community platform built with .NET and Blazor. Communities are called planets. Each planet can have chat channels, thread feeds, wikis, voice and video calls, roles, an economy, and a village where members walk around and meet. The client supports tabs, splits, and multiple open conversations.

Use the app at app.valour.gg or visit valour.gg for the public website. The documentation index covers development, hosting, and architecture.

Codebase

Directory Purpose
Config/ Server configuration classes and a sample settings file
Valour/Client/ Shared Razor UI, client services, TypeScript, styles, and assets
Valour/Client.Blazor/ Browser WebAssembly host for the shared UI
Valour/Client.Maui/ Native application host
Valour/Sdk/ API client, models, caches, and SignalR connections
Valour/Shared/ Shared contracts, permissions, requests, and utilities
Valour/Database/ Entity Framework models and migrations
Valour/Server/ HTTP APIs, SignalR, application services, and content delivery
Valour/Web/ Public website and static exporter
Valour/Tests/ C#, JavaScript, and browser tests
Tools/Villages/ Artwork tools and isolated local test/server runners

The web host references the shared client UI. The server serves API and SignalR requests and can serve the browser client and its static assets. Bots use the same SDK and API contracts as the client.

Self-hosting

The root Docker Compose bundle includes Valour, PostgreSQL, Redis, Caddy, and filesystem media storage. Point a public domain at the host and allow inbound ports 80 and 443. From the repository root:

cp .env.example .env

Edit .env to set the domain, database password, and bootstrap administrator credentials, then start the services:

docker compose up -d

Caddy obtains the HTTPS certificate and proxies the application. The Compose file maps supported .env values into the container. Additional server settings, such as S3 storage or optional integrations, need corresponding entries in the service environment or a Compose override. Merely adding an arbitrary setting to .env does not pass it to the application.

See Deployment for storage, optional services, and cluster operation. Self-hosted voice covers the LiveKit overlay and required media ports.

Federation

A federation hub owns accounts and the global planet registry. Registered community nodes host planets on independent domains. Clients connect directly to those nodes using destination-specific credentials issued by the hub. Their normal Valour session token stays with the hub.

To configure a community node in the Compose bundle, run:

./scripts/valour-node-setup

The wizard configures the domain and hub, creates a private Data Protection key, and asks which owners may move planets to the node. The operator then registers and verifies the public node in the hub's User Settings, Federation screen. Without federation settings, the Compose deployment runs as a standalone instance.

Planet owners start a move from their planet's Federation settings, import the signed grant, verify the destination, and finalize source deletion. Read the federation guide before moving a planet, including its transfer limits and the distinction between a pending and completed handoff.

Contribute

Install the exact SDK in global.json: 11.0.100-preview.3.26207.106. SDK roll-forward is disabled. Local server work also requires PostgreSQL and Redis. JavaScript tests use Node.js, and browser tests require Playwright. Native application builds require their platform workloads.

Restore dependencies from the repository root:

dotnet workload restore
dotnet restore

Create the ignored Valour/Server/appsettings.json using Config/appsettings.helper.json as a guide. Configure Database, Redis, and Node for your local services. Choose filesystem media storage for local uploads, and configure optional services only when needed. The helper file is a list of settings with placeholders, not a ready-to-run config.

The server applies Entity Framework migrations on startup. Start it with:

dotnet run --project Valour/Server/Valour.Server.csproj

The development launch profile uses https://localhost:5001 and http://localhost:5000. The server's startup output identifies the listening URLs. The browser client resolves its API address through its hosting configuration.

Build from the root with dotnet build. C# integration tests start application services and need a dedicated test database and Redis instance. Use the isolated test runner rather than running them with a personal or shared server configuration. JavaScript tests run with node --test Valour/Tests/Js/*.test.mjs after compiling the client sources.

Release builds that reference the local village atlas require the matching private art asset. Follow Village tilesets to generate or restore it before publishing.

Read Reactive models before changing model caches, events, or node connections. For server work, see API routing and Roles. Use GitHub issues for bug reports and feature discussions. Report vulnerabilities using SECURITY.md.

Trademark Notice

The name "Valour" is a trademark of Valour Software LLC, and a trademark application is pending. While the project is open-source, use of the trademark must not imply endorsement by Valour Software LLC or mislead others regarding the origin of the project.

Forks or derivative projects may not use the name "Valour" or related branding without prior written permission from Valour Software LLC. Any use of the trademark outside the scope of this project requires explicit permission.

While use of the trademark is not permitted for forks of the project itself, use of the mark is allowed for Valour bots, plugins, or integrations. If you are unsure, contact us!

Frequently asked questions

Is Valour free to use?

Valour is open source under the AGPL-3.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Valour do?

Community-driven platform built for transparency

What is Valour written in?

Valour is primarily written in C#. Its source is publicly available at https://github.com/valour-software/valour, and it has 397 GitHub stars.