Mold your development experience
Glamorous Toolkit is the Moldable Development environment. It empowers you to make systems explainable through experiences tailored for each problem.
Download for Mac, Linux & Windows
It's free and open-source. Star us on GitHub.
Your own development experience
Programming, exploring data, browsing APIs, knowledge management, log investigations, domain modeling are all part of the same continuum. They require dedicated tools, but those tools can come to you in an integrated experience that is specific to your context. This is the essence of Moldable Development. And this is what Glamorous Toolkit makes practical.
A single environment. Many applications
Glamorous Toolkit offers a uniform environment made out of visual and interactive operators that can be combined inexpensively in many ways.
Explaining a domain object through examples and custom views.
An interactive exploration of dependencies between ActiveRecords in a Rails application that also shows the Ruby and SQL sources.
Exploring a REST API through custom views.
Exploring the data exported from a Twitter account.
Exploring the book about Glamorous Toolkit written in Glamorous Toolkit.
Editing a AT Protocol lexicon definition at the domain level: highlighting of name strings, completion inside JSON strings, navigation from a reference to its definition.
Made to work with many languages and technologies
Glamorous Toolkit is implemented in Pharo but it was designed to be extended for other technologies and languages. It can be used to analyze various sources such as Java, C#, Ruby/Rails, Python, TypeScript, JavaScript, React or COBOL. And it can be used to work with various runtimes like GraphQL, Python, JavaScript or Gemstone.
Editing GraphQL and exploring a server response from a Lepiter page.
A dedicated environment for defining support for other languages.
Exploring COBOL screens, control flows and source code.
Explaining a tokenization algorithm implemented in Python.
Moldable knowledge management + multi-language notebooks
Glamorous Toolkit is powered by the Lepiter knowledge base engine. Lepiter is made out of snippets grouped into pages and can be used for various use cases. And like every part of the environment, Lepiter is also moldable.
An example with a preview embedded in a Lepiter page. The example is defined and viewed in a dedicated snippet.
A page with a JavaScript snippet that is combined with a Pharo snippet to produce a visualization of dependencies defined in a Yarn file.
A completion inside a custom todo annotation. The completion shows a date dialog for the due date.
On the left, we see a page with a Wardley Map in which one of the nodes has a link to another page. On the right, the linked page shows the Wardley Map as one of the references.
Visualizing the current knowledge base through a Pharo snippet. Clicking on nodes opens the page to the right.
A page containing text with two links and an example snippet. The second link ("Examples") appears expanded because the cursor is next to it. At the bottom, the example snippet shows the parameters when the mouse hovers.
Flexible graphical stack
All visual scenes are rendered using a single underlying tree, including the editor and visualizations. This allows us to create flexible, unforeseen experiences.
Inspecting the rendering tree and asking for the implementation of a shortcut available in a text snippet.
Extensible editor
The editor is made out of the same elements as every other visual widget in the interface. Because of this you can add adornments anywhere in the text. Combined with stylers, you can produce surprisingly elaborate editing experiences.
An editor on the definition of the Glamorous Toolkit baseline. The editor understands the meaning of the string because of the baseline specification interface and offers an expander adornment accordingly.
Built-in visualization engine
Visualizations are also made out of elements and are arranged through layouts modelled like any other layouts. The consequence is that visualizations are not confined to isolated panes. You can combine widgets with visualizations arbitrarily.
A visualization inside an inspector. The visualization shows editors of examples and their dependencies. The lines connect the editors with the other editors, and when the code reference is visible, with the element inside the editor.
What would you do if your tools had no walls?
Rigid tools make you split your problem along their boundaries. Glamorous Toolkit turns the problem upside down. Instead of relying on single purpose tools, you get an environment made out of interactive and visual operators with which to construct an integrated experience customized for your needs.
Reimagined Pharo development experience
Of course, Glamorous Toolkit does offer an extensive environment for Pharo development. It reuses the Pharo language implementation and core libraries, but it comes with a whole new environment that enables a new way of programming. Yes, new even for the Smalltalk world.
Live development in snippets and inspectors
Traditionally, Smalltalk development happened in the code browser and in the debugger. In Glamorous Toolkit you get to work in snippets and inspectors.
Creating a class directly while programming in a Pharo snippet.
Changing the class of an object in a full fledged coder embedded in the inspector. Executing code is also possible because self has a concrete value.
Unified exploration flow
Exploration is paramount in software development. Glamorous Toolkit helps you follow casual links at arbitrary levels and across tools.
A Lepiter page containing a visualization of a class hierarchy. Clicking on a node in the visualization opens a Coder on that classes.
Enhanced coders
Editing Pharo code is empowered by the flexible editor, but can also be customized in many ways with technology and system specific extensions.
Expanding PetitParser productions: this time, the expansion is framework specific and happens for a variable that is resolved to the corresponding method.
A class coder on the baseline definition of Glamorous Toolkit showing a map of the dependencies between projects. Selecting one project spawns a coder to the right.
Composable tools
The goal of Glamorous Toolkit is to empower you to mold your own development experiences. So, tools are not monolithic. Instead, they are made of reusable and composable operators.
A search in the global Spotter.
A Spotter in an inspector showing custom searches defined in the inspected object (and addressbook, in our case).
Example-driven development
The entire environment is tested and documented based on examples. Examples are like tests that return objects. This small change has interesting consequences.
Examples form graphs: you can build on top of other examples by using their returned objects. Examples are documentation, too: by combining the returned objects with custom views and a flexible knowledge base, you get the pieces out of which to build larger executable narratives.
A graph of examples. Executing an example shows the inspector to the right. In this case, the resulting object is a text editor showing an adornment for tracking cursor indexes.
The same example embedded both as code and as a result in a page that is part of the Glamorous Toolkit book.
Filters as first class citizens
Searching source code has always been a Smalltalk thing. Now, it's even more pervasive and composable.
References and implementers are just filters over code that, once inspected, show the code matches in live editors. Filters can be composed programmatically, too. When combined with inspectors, you get pervasive search opportunities.
Searching for references to a message in the current hierarchy.
An example of a composite filter combining searches for pragmas, references and abstract syntax tree matches.
Enhanced refactoring and rewrite support
Automatic refactorings were first implemented in Smalltalk. The engine remains the same, but the experience became more ... glamorous.
You can perform complicated refactorings directly in the editor. Furthermore, automatic code rewriting is a superpower, but can be difficult to master. No longer. You can now define rewrites by example.
An example of a refactoring editable inline.
A snippet defining a custom rewrite with the preview of code changes.
Extensible forms
The input forms in Glamorous Toolkit are handled through Magritte, a forms engine.
Adding a class through a form. Different fields offers different completion and validation.
No modal dialogs
A complete environment. No modal dialogs. Not even one. We are quite proud of this, too.
Closing the last window prompts for saving without a fully modal dialog.
Removing a method with references opens a dropdown to inform about those references, including allowing for the option of seeing the references to the right.
Rust enabled runtime
The Glamorous Toolkit virtual machine is formed by a Rust runtime that wraps and runs the Pharo virtual machine as a library in a separate operating system thread. The runtime also comes with Rust plugins and with an infrastructure for creating Rust plugins.
Inspecting a Pharo object that wraps a Rust object. The second and third panes show Rust objects in a seamless navigatio.
Distributed asynchronous images
Glamorous Toolkit comes with a asynchronous mechanism to work with multiple remote images. The remote images pull from a queue of tasks and can communicate back through a second asynchronous communication channel.
So, what exactly is Moldable Development again?
Please, take another look through this page. What do you see?
You see many shapes. The premise of Moldable Development is that there is no single perspective on a system that is correct. There are always many, and different parts of the system are best shown differently. These shapes summarize the system from specific perspectives. This then leads to a compressed communication and a new feedback loop.
Moldable Development is a way of programming through custom tools built for each problem. It's a systematic approach that can be employed at any level of abstraction.
Glamorous Toolkit itself is an extensive case study of how custom tools enhance programming abilities. It comes out of the box with thousands of extensions and examples that touch on the whole system.
The goal? To make the inside of systems explainable.
The need for moldability is pervasive. The treemap shows the classes of Glamorous Toolkit organized in packages. Blue denotes classes that contain at least one custom view; green shows those that have an example.