Here you’ll find the features we’ve built and are building, information around the order in which we’ll be addressing them, as well as functional and technical specifications.
We’ve mapped these features to use cases, so if you’re interested in using HASH for a particular thing, you can follow along (or even contribute!)
Knowledge Management
Data Management
Business Intelligence
Website Building
Internal Tools/Apps
Agent-Based Simulation
Entity Storage/
Inspired by the “tech trees” of video games like Civilization, we’ve broken down the key components required to build HASH into a tree-view below. You can filter these by use case to see what’s left to be built unblocking a particular use case, or slice the data by work area or completion status.
Filters
By Status
By Type
By Use Case
Frontend App Scaffolding
Basic application screens and frame implemented
Infrastructure
Done
UX/UI Outline
Basic application screens and functionality outline
Infrastructure
Done
Graph Layer
Rust implementation of the Graph Module atop Postgres
Infrastructure
Done
Block Protocol Graph Module
Type System and methods for accessing structured data
Block Protocol
Done
Entity Validation
Validate that entities comply with their schema when inserting and updating
Feature
In Progress
Entity Archival (Soft Deletion)
Ability to archive or hide entities including pages
Feature
Done
Entity Type Editor
Interface for managing entity types in HASH
Feature
Done
Core System Types
User, workspace, and other key types required by HASH itself
Infrastructure
Done
Basic Authentication
Implement login/logout/signup atop Kratos
Feature
Done
Multiplayer Prototype
Proof-of-concept multiplayer editing and live collaboration
Experiment
Done
Realtime Service
Engine for synchronizing data between backend datastores, user sessions (via Collab), and external services (via Flows)
Infrastructure
Done
Search Prototype
MVP implementation of OpenSearch-based full text search
Experiment
Done
Entity Editor
Interface for managing entities in HASH
Feature
Done
File Entity Viewer
Application-level support for rendering binary files using blocks on File entity pages
Feature
Future
Custom Data Types
Interface allowing user definition of non-primitive Data Types
Feature
Future
Custom Data Types RFC
Proposed specification extension allowing for user-defined non-primitive Data Types
Block Protocol
Next Up
Type Inheritance RFC
Proposal for supporting type inheritance in the Block Protocol Graph Module
Block Protocol
Done
Type Inheritance
Set parent types whose expected property and link types will be inherited
Feature
In Progress
Multi-Type Entities
Allow a single entity to have more than one assigned type
Feature
Future
Data Mapping RFC
Proposal for a system to map between data of different types
Block Protocol
Future
Semantic Data Mapping
Description coming soon
Feature
Future
Structural Data Mapping
Description coming soon
Feature
Future
Calculated Properties
Programmatic calculation of properties, supported independently of Flows.
Feature
Future
Linear Pages
Single-column block-based documents
Feature
Done
@mentions
Ability to @mention users and other entities within pages
Feature
Done
Text Hook Provider
Hook provider for rich text-editing within blocks
Infrastructure
Done
Block Protocol Hook Module
Inject native application experiences and handlers within blocks
Block Protocol
Done
Block Protocol Core
Specification for passing structured data between blocks and embedding applications
Block Protocol
Done
Basic Primitive Blocks
Key blocks such as heading, paragraph, image, etc.
Feature
Done
Data Querying & Selection
Interface for identifying and loading entities into blocks
Feature
In Progress
Advanced Blocks
Blocks which allow users to query and insert multiple entities of varying types (e.g. table, kanban, timeline)
Feature
Future
Block Protocol Service Module
Allow blocks to connect to external services without handling integration logic themselves
Block Protocol
Done
Block Protocol API Middleware
Handler for OpenAI, Mapbox and other third-party APIs
Block Protocol
Done
API-Based Blocks
OpenAI and Mapbox-enabled blocks built atop the Þ API middleware
Feature
Done
Authorization
Basic permissions and attribute-based access control (ABAC)
Feature
Future
User & Org Administration
Basic account and shared workspace management
Feature
In Progress
Notifications
User-facing in-app alerts upon notifiable events
Feature
Next Up
Task Executor
Temporal-based executor for flows and other logic
Infrastructure
Done
Flows
Scheduled and responsive execution of user-defined logic
Feature
Next Up
AI Type Creation
LLM-assisted new and existing type suggestions
Feature
In Progress
AI Entity Creation
LLM-assisted new entity creation
Feature
In Progress
Type Archival (Soft Deletion)
Ability to hide outdated or redundant types in the UI
Feature
In Progress
External API & Webhooks
API endpoints for interfacing with HASH designed for external user consumption
Feature
Future
Block-Level Comments
The ability to comment on blocks within pages
Feature
Done
Canvas Pages
Freeform drag-and-drop canvases for blocks
Feature
In Progress
Canvas AutoLayout
Dynamically position blocks relative to one another
Feature
Future
Command Bar
Command or k-bar for quickly accessing AI capabilities and shortcuts
Feature
Done
Shortcut Cheatsheet
Easy, centralized in-app access to keyboard navigation documentation
Feature
Future
Keyboard Navigability
Full support for using HASH via keyboard alone
Feature
Future
Similarity Search
Generation of per-entity, property, link and type embeddings, vector datastore backend, and frontend
Feature
Future
Semantic Q&A
Natural language questions and answers based on the contents of a workspace and (optionally) global graph
Feature
Future
Text Search
Production-ready implementation of full-text search
Feature
Future
Git Datastore
libgit2 or Gitea-based backend for dedicated storage and processing of source code and Git repositories
Infrastructure
Future
Simulation Blocks
Replaces hCore, enabling simulations and experiments to be created and run in HASH
Feature
Future
Time Series Datastore
Open-source (TBD) backend for dedicated storage and processing of time series data
Infrastructure
Future
Optimized Simulation Run Storage
Move to a more efficient data format for storing simulation data (e.g. Parquet)
Infrastructure
Future
Improved scalability
Intelligent offloading of infrequently accessed data into cold storage
Infrastructure
Future
Self-service hCloud
Offered up until May 2023, we plan to re-introduce this as part of Flows
Feature
Future
REPL Block
Support for individually executable blocks (JavaScript/Python notebook-style) within pages
Feature
Future
Block Protocol Actions Module
Specification for users/apps defining block action-handling
Block Protocol
Next Up
Block Action Mapping
Interface for mapping blocks to available actions
Feature
Future
Action Blocks
Basic blocks designed for data- and action-mapping (e.g. button, dropdown, etc.)
Feature
Future
Apps
Ability to bundle entites, types, and blocks on pages into distributable apps
Feature
Future
App Store
Publish and distribute or discover user-created HASH Applications
Feature
Future
Financial Accounting Datastore
TigerBeetle-based backend for dedicated storage and processing of financial accounting data
Feature
Future
Ramp Integration
Ability to read information from Ramp and take actions via Flows
Feature
Future
Brex Integration (read-only)
Ability to read information from Brex and take actions via Flows
Feature
Future
Multiplayer Editing
Y CRDT-based production implementation of collaborative page, entity and type editing
Feature
Future
Integrations: Realtime sync
Ability to synchronize information to/fro external services via the Realtime Service
Experiment
Done
Linear Integration
Two-way sync of information with one or more Linear workspaces
Feature
In Progress
GitHub Integration
Two-way sync of information with GitHub and ability to trigger actions via Flows
Feature
Next Up
Gmail/Google Workspace email sync
Read and manage (two-way sync) emails stored in Gmail and Google Workspace
Feature
Future
Integrations: One-time write
Ability to write information out to connected external services
Experiment
Done
Email Sending
Support for user composition/triggering of emails via Flows
Feature
Future
Integrations: One-time load
Ability to ingest information from external services as entities
Experiment
Done
Notion Integration
Ability to one-time import information from Notion (two-way sync when Notion supports webhooks)
Feature
Future
Asana Integration
Two-way sync of information with one or more Asana organizations
Feature
Future
API Transactions
Complex API requests composed of multiple interdependent operations
Feature
Future
Entity/Property Hard Deletion
Ability to permanently delete information from the backend datastore(s)
Feature
Future
Got a use case in mind?
Discuss your use case by contacting us or joining the Discord community.