A Go implementation of Media over QUIC Transport (MOQT), specifically implementing the MOQ Lite specification for efficient media streaming over QUIC.

This implementation follows the MOQ Lite specification, providing a foundation for building real-time media streaming applications using QUIC transport. MOQ Lite is a simplified version of the Media over QUIC Transport protocol, designed for lower latency and reduced complexity while maintaining the core benefits of QUIC-based media delivery.

• MOQ Lite Protocol: Core implementation of the MOQ Lite specification
• WebTransport Support: Full support for WebTransport connections in browsers
• Raw QUIC Support: Direct QUIC connections for native applications
• Track Management: Publisher/Subscriber pattern for media track handling
• Multiplexed Streaming: Efficient multiplexing of multiple media tracks
• Sample Applications: Complete examples demonstrating various use cases

The core Go package implementing the MOQ Lite protocol interactions, including:

• Session establishment and management
• Track publishing and subscription
• Announcement handling
• Stream multiplexing and routing

This implementation is specifically designed for the MOQ Lite specification, focusing on simplicity and performance for real-time media streaming applications.

TypeScript/JavaScript implementation providing WebTransport support for browsers, including:

• WebTransport session management
• Stream ID calculation and tracking
• Reader/Writer interfaces for QUIC streams
• Integration with browser WebTransport API

Interoperability testing tools and examples for validating MOQ implementations across different platforms.

• Go 1.25.0 or later
• just command runner

1. Clone the repository:

   git clone https://github.com/OkutaniDaichi0106/gomoqt.git
   cd gomoqt

2. Install the package:

   go get github.com/OkutaniDaichi0106/gomoqt

3. Set up the development environment:

   just dev-setup

This command will perform the following:

• Install the required certificate tools (mkcert).
• Install development tools (goimports, golangci-lint).
• Download project dependencies.
• Generate development certificates.

# Start the interop server
just interop-server

# In another terminal, run the interop client
just interop-client

# Format code
just fmt

# Run linter
just lint

# Run tests
just test

# Perform overall quality checks (formatting and linting)
just check

# Build the code
just build

# Clean up generated files
just clean

The examples directory includes sample applications demonstrating how to use gomoqt:

• Interop Server and Client (interop/): Interoperability testing between different MOQ implementations
• Broadcast Example (examples/broadcast/): Broadcasting functionality demonstration
• Echo Example (examples/echo/): Simple echo server and client implementation
• Native QUIC (examples/native_quic/): Direct QUIC connection examples
• Relay (examples/relay/): Relay functionality for media streaming

• GoDoc
• MOQ Lite Specification
• Implementation Status - Detailed implementation progress

This implementation targets the MOQ Lite specification, which provides a simplified approach to Media over QUIC Transport. The current implementation status can be found in the moqt package README, which includes detailed tracking of implemented features according to the specification sections.

We welcome contributions! Here's how you can help:

1. Fork the repository.
2. Create a feature branch (git checkout -b feature/amazing-feature).
3. Make your changes.
4. Verify code quality:

   just fmt
   just lint
   just test

5. Commit your changes (git commit -m 'Add amazing feature').
6. Push your branch (git push origin feature/amazing-feature).
7. Open a Pull Request.

This project is licensed under the MIT License; see LICENSE for details.

• quic-go - QUIC implementation in Go
• webtransport-go - WebTransport implementation in Go
• MOQ Lite Specification - The specification this implementation follows