Mold your development experience
Glamorous Toolkit is the Moldable Development environment. It empowers you to make systems explainable through experiences tailored for each problem.
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.
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.
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.
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.
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.
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.
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.
Unified exploration flow
Exploration is paramount in software development. Glamorous Toolkit helps you follow casual links at arbitrary levels and across tools.
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.
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.
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.
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.
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.
Extensible forms
The input forms in Glamorous Toolkit are handled through Magritte, a forms engine.
No modal dialogs
A complete environment. No modal dialogs. Not even one. We are quite proud of this, too.
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.
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.