Open Evnt

Currently for calendaring on the web, the de-facto standard is iCal. However, iCal has a number of issues that make it difficult to use.

If you have ever tried to use iCal or the applications that use it (e.g., Apple Calendar, Google Calendar), you have probably run into some of these issues as a user:

• Calendar applications often have poor support for iCal, leading to inconsistent and unreliable behavior across different applications.
• You can't reliably have more detailed information using iCal, such as events with multiple locations like hybrid events, events that span multiple days, uncertain dates, localized event names and descriptions, and more.
• You can share events using iCal, but it is not very reliable and often leads to vendor lock-in.
• Many websites that list events do not work using iCal, and instead use their own proprietary formats that are not interoperable with other applications.

And if you are a developer, you have probably run into some of these issues as well:

• iCal is a complex format with many edge cases and quirks that make it difficult to implement correctly. This has led to a number of bugs and inconsistencies in iCal implementations.
• iCal is not designed to be extensible, making it difficult to add new features or support new types of events. This has led to a number of workarounds and hacks in iCal implementations.

Open Evnt is designed to fix these issues by providing a modern, extensible, and easy-to-use data format for events. It is based on JSON, which is a widely used and well-supported data format that is easy to work with for developers.

The idea is simple: define a common format for calendar applications, event management systems, event listing sites and others to use for representing events. This allows for better interoperability between different applications and services, and makes it easier for developers to create new applications and services that work with events.

So yes, we are reinventing the wheel: XKCD 927

• Multilingual - Every text field in Evnt supports multiple languages (by using language-keyed objects). This means that internationalization is built into the core of the format.

  {
    "en": "Example message",
    "lt": "Pavyzdžio pranešimas"
  }

• Instances - Events can have multiple time spans. Many events (e.g. conferences) have multiple instances, and it is important to be able to represent that in a consistent way.
• Venues - Events can have multiple venues, both physical and online. This is important for events that have multiple physical locations (e.g. a conference with multiple stages) or that are hybrid (e.g. a conference with both physical and online attendees).
• Partial Dates - Some events only have partial date information. For example, you might only know the month and year of an event, but not the exact day. Evnt allows you to represent this in a consistent way by allowing partial date strings (e.g. "2024-05" for May 2024).
• No Timezones - Everything is stored in UTC, and it's up to the application to convert it to the user's local timezone.
• Metadata - Information that don't belong to a specific instance or venue can be stored as Components, which are extensible.

  We currently have:

  • Links - Links related to the event (e.g. website, social media, registration form etc.); they can have titles, descriptions and even defined times for when they are valid.
  • Splash Media - Images or videos that represent the event. Applications can use this to display a banner for the event, for example.

  Components can also be defined by applications, and they can be used to store any kind of metadata that doesn't fit into the predefined fields.

Evnt is still a relatively new project, so there aren't many applications using it yet.

Applications using evnt

Application	Description		Source
Vantage	Default, reference implementation of an event viewer	/	Link

These applications all support the eventsl.ink link format which allows you to share links to your events that can be opened in any of these applications.

If you're building an application using Evnt, please let us know!

You can find the specification for Evnt in docs/README.md file in the GitHub repository.

We have a npm package for the schema that uses Zod and provides TypeScript types as well as runtime validation. You can find it on npm as @evnt/schema.

pnpm add @evnt/schema

We also auto-generate a couple things using the @evnt/schema code:

• A JSON Schema for the event data, which can be used for validation and type generation. You can find it in event-data.schema.json. Here's a raw link you can use as $schema:

https://raw.githubusercontent.com/deniz-blue/events-format/refs/heads/main/event-data.schema.json
Expand code

• A markdown document that documents all the type information.

The Evnt format is compatible with ATProto.

Applications should use the directory.evnt.event collection for events.

You can find the lexicons below. Lexicon version 1 does not support the neccesary features to fully represent the evnt schema, so this is a very rough approximation.

Currently the standard collection for events is the community.lexicon.calendar.event lexicon. Unfortunately, Evnt is more complex so these two lexicons are not fully compatible.

Applications wishing to support both lexicons can use the same TID and do conversion between the formats.

The community.lexicon.calendar.rsvp lexicons can be used for RSVPs since subject field is a com.atproto.repo.strongRef and allows referencing the event in the directory.evnt.event collection.

Here is a comparison table showing how Evnt compares to some other event formats:

We don't want to overrate our own format so feel free to point out things to add here.

Here is a couple of code examples of evnt events:

{
  "v": 0,
  "name": {
    "en": "No venues"
  },
  "instances": [
    {
      "venueIds": [],
      "start": "2027-03-08T09:00",
      "end": "2027-03-08T18:00"
    }
  ]
}

Use the section below to validate JSON in the format

Preview