Atria - Event Management & Professional Networking Platform

Build meaningful connections that last beyond your events.

Version

⭐ If you find Atria interesting, please consider starring this repository — it helps us grow and reach more people who could benefit from the platform.

What is Atria?

Atria is an open-source event management platform that combines comprehensive event administration with intelligent networking features. Unlike bloated enterprise tools or feature-creep SaaS platforms, Atria focuses exclusively on what matters: your event and the connections made there.

Why Atria?

Event-Focused, Not Platform-Focused When you're managing an event, you see only that event. No distracting sidebars, no unrelated organizations, no feature overload. Just powerful tools to run your event and facilitate meaningful networking.

True Open Source & Data Ownership

AGPL-3.0 licensed - complete transparency and freedom
Your data stays yours - export or migrate anytime, no vendor lock-in
Self-host or cloud - run it yourself for free, or use managed hosting
No surprise pricing - never held hostage by sudden price increases
Community-driven - talk directly to the developers who built it

Built for Real Events

Corporations: Conferences, product launches, training events
Nonprofits: Fundraising galas, awareness campaigns, volunteer coordination
Education: Academic conferences, workshops, alumni gatherings
Faith Organizations: Church conferences, community gatherings, ministry events
Communities: Professional associations, industry meetups, local events

📰 Stay Updated: Follow our blog for release notes, feature announcements, and platform updates.

Quick Start

Prerequisites

Before you begin, ensure you have:

Docker & Docker Compose (recommended for quickest setup)
Node.js 20+ and Python 3.13+ (if running outside Docker)
PostgreSQL 15+ (included in Docker setup)
MinIO or S3-compatible storage (required for file uploads)
- See MinIO on GitHub for self-hosted option
- Or use AWS S3, DigitalOcean Spaces, or other S3-compatible service
Redis (optional but recommended for caching and real-time features)
- App works without Redis (graceful degradation) but with reduced features

Installation

Clone the repository

git clone https://github.com/thesubtleties/atria.git
cd atria

Configure environment
```
# Copy environment files (you need BOTH)
cp .env.example .env                                # For Docker Compose
cp .env.development.example .env.development        # For backend app
```
Why two files?
- .env → Used by Docker Compose to set up PostgreSQL (minimal config)
- .env.development → Used by the Flask backend application (full config)
For local development, the defaults work out of the box! For production, edit:
- JWT secret keys (generate new ones!)
- MinIO/S3 credentials (for file uploads)
- Email settings (for invitations)
- Redis URL (for caching and real-time features)
Start the platform

Option A: Using the interactive chooser (recommended)
```
./dev-environment-chooser.sh
```
Select option 1) Standard Local Development for the simplest setup.
- The chooser will ask if you want to seed the database with sample data
- Recommended: Say yes (y) for first-time setup to get sample organizations, events, and users
Option B: Direct Docker Compose (no tmux required)
```
docker compose -f docker-compose.dev-vite.yml up
```
By default, this will automatically seed the database with sample data.

To disable automatic seeding:
```
SEED_DB=false docker compose -f docker-compose.dev-vite.yml up
```
Note: Sample data includes test organizations, events, users, and sessions to help you explore features immediately.
Access your platform
- Frontend: http://localhost:5173
- Backend API: http://localhost:5000
- API Documentation: http://localhost:5000/new-swagger
- Health Check: http://localhost:5000/api/health

The development environment includes:

Hot reload for frontend and backend
PostgreSQL database (seeded with sample data by default)
Automatic dependency installation

Need more detailed setup instructions? → Full installation guide

Core Features

Event Management

Multi-day events with complex session scheduling
Drag-and-drop speaker management with role assignments
Real-time session status updates
Hybrid event support (virtual + in-person attendance)
Multi-platform video streaming (Vimeo, Mux with signed playback for token-based video security, Zoom)
Session-specific chat rooms (public and backstage)

Professional Networking

Icebreaker system for personalized connection requests
Attendee discovery by role and interests
Privacy controls for profile visibility
Connection management and tracking

Real-Time Communication

Multi-level chat system (general, Q&A, networking, session-specific)
Direct messaging between attendees
Administrative and backstage channels
Live session chat during presentations
Socket.IO powered instant messaging

Multi-Tenant Architecture

Organization-level management with data isolation
Role-based access control (Organization: Owner > Admin > Member)
Event-level permissions (Admin > Organizer > Moderator > Speaker > Attendee)
Cross-organization event support
Complete data security and separation

Sponsor Management

Multi-tier system (Platinum, Gold, Silver, Bronze, custom levels)
Rich sponsor profiles with logos, descriptions, links
Drag-and-drop reordering for visual organization
Automatic image optimization (WebP conversion, 80-90% size reduction)

Security

HTTPOnly cookie authentication (XSS protection)
JWT with automatic refresh tokens
Granular role-based permissions
Secure file storage with three-tier access control
Multi-tenant data isolation

Developer Experience

Comprehensive OpenAPI documentation
RESTful API design
Real-time Socket.IO event system
Hot reload development environment
Docker-first deployment

Technology Stack

Backend

Python 3.13 with Flask framework
PostgreSQL 15 with SQLAlchemy ORM
Redis 7 for caching, presence tracking, and Socket.IO clustering
Flask-SocketIO for real-time features
S3-compatible storage (MinIO, AWS S3, or similar) for file uploads
SMTP2GO for transactional emails

Frontend

React 18 with Vite 6 build system
Mantine UI 7 component library
Redux Toolkit + RTK Query for state management
Socket.IO Client for real-time updates
Zod for runtime validation

Project Status

Current State: Live at atria.gg with active development

Live deployment at atria.gg
196 passing tests (~47% backend coverage, target: 80%+)
Automated CI/CD with GitHub Actions
Multi-instance scaling ready (Socket.IO clustering with Redis)
Actively maintained with regular updates

Roadmap highlights:

Advanced reporting & analytics
Interactive polling system
Ticketing integrations
AI-enhanced features (session imports, chat host)
Custom event theming
Enhanced mobile experience

Full roadmap & changelog → docs.atria.gg/roadmap

Documentation & Resources

Complete Documentation: docs.atria.gg
API Reference: docs.atria.gg/docs/api/atria-api
Community Support: GitHub Discussions
Bug Reports: GitHub Issues
Commercial Support: steven@sbtl.dev

Contributing

We welcome contributions from the community! Whether fixing bugs, adding features, or improving documentation, your help makes Atria better for everyone.

Before contributing, please:

Quick contribution guide:

Fork the repository and create a feature branch
Follow existing code style and patterns
Add tests for new functionality
Update documentation as needed
Submit a PR with clear description

All contributions must pass our CI test suite before merging.

Licensing

Open Source (AGPL-3.0)

Atria is licensed under the GNU Affero General Public License v3.0.

You can:

Use, modify, and distribute freely
Run for any purpose including commercial use

Requirements:

Modifications must be licensed under AGPL-3.0
If you run modified code on a server, you must provide source code to users
Attribution required: Keep "atria is made with ❤️ by sbtl" in the UI
- "atria" links to https://atria.gg
- "sbtl" links to https://sbtl.dev

Full attribution requirements → LICENSE-ATTRIBUTION.md

Commercial License

For organizations that cannot comply with AG

Atria

Install / Use

README