Tiles: A browser for open source information
Tiles is a browser for Ceramic streams that empowers anyone to explore, inspect, and eventually transform open information flows.
Tiles is the first browser for content on the Ceramic Network. Built by several early Ceramic community members, Tiles is the easiest way to explore all streams being created and updated on the network or to examine the content of any given stream. It also helps developers discover the formats, schemas, and metadata being used by others, enabling them to build their applications with common data formats and patterns.
With upcoming features such as lenses, Tiles is primed to help Web3 developers create an open-source approach to data management and unlock more expressive UIs and experiences for their users.
The cost of fragmented data
We've gotten so used to the fragmentation of data on Web2 that we sometimes forget how much it costs us. Developers and product builders are forced to contend with this fragmentation whenever they want to consume and make use of data from multiple sources. Similarly, users are forced to deal with data lock-in resulting in limited data in any single application or frustrating processes to manually export and connect data across multiple applications – usually with very limited success.
Oaksprout, one of the creators of Tiles along with his collaborator Izzy, has been trying to work around the patchwork data architecture that exists in Web2 for nearly a decade. He says:
Services built on top of fragmented data are wildly limited because you can't aggregate information across them, which means that services in the Web2 world are just really, incredibly underpowered.
Since Web2-powered products run on data stored in private database servers which are independently controlled and managed, there is no way for third parties or the general public to input or agree on the proper formats for certain types of data. Even in cases where a given data object is so common that it should conform to a standard — say, the format for a blog post or how to represent a step in a fitness tracker — each vendor will choose to implement their own model and schema for that data with no natural way to collaborate and coordinate with other vendors storing or consuming data for the same type of object.
In this paradigm every application exists only within its own silo, unable to connect with other applications or experiences that a user has on the web. Because of this, developers are forced to start cold or succumb to being locked into a specific platform, rather than being able to build on existing patterns that the ecosystem has aligned around and the data that has been created within other applications. If disparate, third-party applications and data sources were able to connect more easily, developers would be able to build richer and far more seamless user experiences, while dramatically accelerating development speed.
Consensus on data models
One great promise of the distributed web is data interoperability and composability: the ability to use the same content across different contexts, organizations, and applications. In practice, data interoperability requires more than just decentralized storage; it requires the ability for many different, unrelated parties to openly discover, interpret, and transform data formats and schemas - and eventually, over time, converge on them.
The Tiles team sees Ceramic as a promising solution for enabling distributed parties to come to consensus on data models for any use case. On Ceramic, data formats and schemas are published openly, where they can easily be discovered by others, and updated over time while maintaining a complete version history. This allows developers to examine the data models for popular applications and data sets, to discover standards being used widely, and to use them or extend them.
Ceramic offers an open-source approach to data, which can revolutionize how we interact with data on the web.
Tiles v1: A stream browser
Tiles aims to provide an interface that makes it easy for developers to discover and make use of collaborative data models on Ceramic. The first version of Tiles is a simple streams explorer which lets users input a streamID to see the content it contains and the schema it uses. Users can inspect the content of a stream as well as the stream type, format, metadata, and history.
Oaksprout believes that by presenting this information in such a simple and open way, Tiles will inspire developers to explore the possibilities of what Ceramic can enable.
I think that when people can see what's on the network and the kind of streams that are being created, people will intuit what can be done.
Unlocking UIs and customizable experiences
The value of discovering and building on shared data models starts with reusable, cross-application data – but to the Tiles team, this is only the beginning. In the future, they believe that a foundation of dependable, shared data models will give birth to user interfaces (UIs) that are much more customizable, dynamic, and flexible. When applications no longer need to define their own data models or spend time worrying about normalizing and integrating with data from other applications, they all can dedicate more time and resources to innovating much more freely on the UI and experience. Says Oaksprout:
All the [related] data on Web3 will have a very similar structure. That means you can decouple the UI from the data layer and present in any way that you want to.
For example, an application could be built that renders all Web3 blog posts in audio format since the application would be able to dependably ingest blog posts in text format, interpret the schema, and perform any required transformations (if necessary) before rendering the audio output. Everything would already be there to make this possible.
While it's difficult to predict exactly how this freedom will be deployed within applications and what innovations will emerge from it, the Tiles team is already seeing mounting evidence that end-users want the ability to program and customize their online experiences more than in the past. As one small example, Oaksprout believes that users' obsession with dark mode is only partly about the actual screen brightness, and equally about a desire to express their preferences in their own tools.
People are tired of having one point of view, a Silicon Valley aesthetic, forced on them.
The software of today is built rigidly and leaves very little ability for end-users or third-party applications to customize functionality, modify design, or adapt features to better fit their needs, preferences, and desires. The software of tomorrow will enable far more dynamic experiences by building on consensus-driven data models that lower the cost of standardization and reduce the risk of incompatibilities.
Lenses for rendering data in apps at runtime
Currently, Tiles only lets users search and explore data streams on Ceramic. However, soon the product will expand into allowing users to view that data in new ways. For any stream, Tiles will allow users to choose a lens (format/view) through which to render and view that content. After a user selects their lens for a given stream, Tiles will transform the UI and display the content in the desired manner. This is all possible due to public schemas.
Eventually, Tiles aims to enable the dynamic rendering of data into various formats and UIs using a concept it calls "Lenses," which act as a way to view or transform data streams at runtime into the proper format for a given application.
Tiles will give UIs the benefit of a very consistent consensus layer around data structures.
At scale, lenses enable the same data to be leveraged across many different applications and experiences without requiring that all parties come to an explicit consensus on data schemas, or worry too much about maintaining version compatibility. Instead, with lenses, data can be transformed as needed between different versions, schemas, or formats directly inside an application's front-end at runtime. These lenses could be used directly in Tiles to examine data, but also deployed by developers to render data in different ways within their own applications. Oaksprout discusses the possibilities for lenses in this clip:
As Tiles builds towards this ecosystem of open data models and runtime rendering options, they also envision helping the community curate the most useful lenses. For any given schema, the community could curate which lenses are most valuable and which defaults should be used.
Beyond curating smart, global lens defaults for common data, lenses could also be specifically curated for different use cases, communities, or unique individuals. This combination of curating the best lenses globally and the best lenses for a given moment can make Tiles a key component of Web3's open source information flows.
Tiles: Next Steps
Apart from further developing the concept of lenses, Tiles will continue to add functionality to their application as more projects onboard onto Ceramic mainnet and more streams are created. In the near future, the Tiles team aims to explore two additional areas of focus:
- Maturing their Ceramic indexing service in order to expose the interdependence and intersection of data that can be found on the network
- Developing an open set of streams that can be used as data structure building blocks that will serve as frameworks for content on Ceramic
If any of this piques your interest, please join the Tiles project discord and start contributing!
Website | Twitter | Discord | GitHub | Documentation | Blog | IDX Identity