Prototype turning into an open source text editor.

• Code on GitHub.
• Rants and News on Twitter.
• Streaming on Twitch.
• Support on Patreon.

Hale is made all from scratch, only utilizing necessary platform libraries to do it's job.

There is some notation used in the following document.

• P in prototype
• H in handmade
• ½ partially in handmade
• * not yet implemented

• α alpha release (hopefully after the 11 days marathon, some features may be scaled down to their simpler versions)
• β beta release
• γ gamma release

Some of these goals are motivated by my desire to learn and try new things. The most important goal is to provide a good and reasonable software that is written for hardware and with love.

Majestic goals follow (disclaimers apply):

• MIT license - Good license to use in various legal settings.
• No build system - Just a .bat and shell scripts. Most of the build configuration in .h files.
• No dependencies - Goal is to not depend on any library. Standard library as an optional dependency.
• No OOP - It's not about neglecting OOP, but mostly about learning to see the code and the data differently.
• Use as component - Easy to embed whole or in parts in other code bases.
• Text and GUI - Text-mode is not dead. Definitely not in today's world of UX targeted at occasional users.
• Multiple OS - Windows at first (α), Linux and Mac (β) will follow.

There is a bit of ambiguity in my goals. It's correct that I want Hale to be both, a library and an application. However I believe the best way to create a library is to first make code that uses it. Therefore I focus to deliver an application at first.

By example: If you are familiar with Scintilla Editing Component (a popular text editing component), you might also know SciTE - Scintilla Text Editor (example editor using Scintilla made by the same author).

The codebase is split into logical modules.

• ½|α Platform - Platform layer support for Windows.
• H|α Foundation - Basic types and general-purpose containers and operations with them.
• H|α Document - Editing and managing documents.
• P|α Scope - Scope-based configuration.
• P|α Bracket - Directory-based configuration.
• P|α Shell - Shell integration.
• P|α UI/Application - Top-level UI management.
• P|α UI/Window - Top-level windows.
• P|α UI/Panel - Window layout.
• P|α UI/Model - Glue between models (Document, Bracket, Shell) and UI.
• ½|α Lua - Lua scripting and configuration.

Although I don't want the core of the editor to contain any "real" features, but rather a foundation for building them, there are still some properties of the system, that can be propagated.

Some other features come from the prototype itself and are lesser versions of what I would like to achieve. However, in order to deliver a working product as soon as possible, I use them as a good placeholder.

• P|α Platform font rendering - Or better: optional platform font rendering. ClearType, for instance, doesn't deal well with some great fonts like Fira Mono or Nitti. FreeType, stb_truetype or distance field font rendering might do a much better job (usually thanks to it's configuration). User has to have that choice for optimal reading experience.
• ½|α Unicode support - 7 bits is not enough. This document itself uses a good portion of Unicode blocks, even though it's entirely in (a bit broken, but) English.
• ½|α Multiple cursors - Editing with multiple cursors and selections at once.
• *|β Large files - Opening and editing extremely large files (16 exbibytes; 2⁶⁴ bytes)
• ½|α Syntax annotation and highlighting - Currently via TextMate-like grammars, however custom parsers are planned to replace this functionality.
• P|α Brackets - A different take on projects and project-based configuration (along with Scope-based configuration).
• P|α Scope-based configuration - Allows you to set different visual and behavioral configuration based on current state of application, window, panel, model, bracket or document.
• P|α Shell integration - Specialized terminal emulator embedded into the application.
• ½|α Lua scripting - A general purpose scripting for prototyping and makeshift extensions.

To not spoil it all, here are a few secret features.

• *|β C++ Scribe - A secret feature.
• *|β Streams - A secret feature.