The Objo Plugin SDK is here

Since we launched Objo Studio, plugin support has been the number one requested feature.

With the latest release (26.10.1), it’s here.

I’m very proud of this addition. The new Plugin SDK gives developers a supported way to bring .NET and native libraries into Objo applications, package them, and share them with other Objo developers. It opens up a huge range of possibilities for what people can build with Objo.

It also means that more people can contribute those capabilities. If you have a useful library, specialist knowledge or an idea for something Objo needs, you now have a way to make it available to the community.

How does it work?

A plugin author writes a C# wrapper that exposes an API to Objo. That wrapper might contain the implementation itself, call an existing .NET library, or use a native library behind the scenes. The SDK generates the bindings and packages the wrapper, its API description and its runtime dependencies into a single .objopackage file.

The resulting API appears in Objo as namespaced classes, constructors, methods, properties, enumerations and events. The Plugin SDK documentation explains the supported types and how to expose them.

Using a finished plugin requires no C# knowledge or .NET development tools. You install the package in Studio, add it to your project and write ordinary Objo code.

For example, once you’ve installed and selected the calculator plugin from the first-plugin tutorial, these statements inside a Command Line project’s Run event create a calculator, add to its total and print the result:

Var calculator As New Example.Maths.Calculator(40)
calculator.Add(2)
Print("Total", calculator.Total)

The result is Total 42.

Studio understands the plugin’s types and members, so you get compile-time checking, autocomplete and signature help. The author’s documentation appears in completion descriptions and hover tooltips too. I wanted using a plugin to feel like using the rest of Objo’s API.

The SDK includes working examples that go well beyond the calculator:

  • A database plugin wraps SQLite with asynchronous operations, typed results and transactions.
  • A document plugin creates and edits DOCX documents through objects such as paragraphs, tables, styles and images.
  • Native image-processing examples demonstrate raw pixel buffers, image effects, progress and cancellation, with integration into Objo’s Picture type.
  • Shared-library examples show how separate plugins can exchange objects from a common foundation package while preserving their type identity.

These are Objo-maintained samples, supplied as starting points for authors. You can explore them in the SDK recipes.

Plugins can support Desktop, Command Line, Web server and Worker projects. For Web applications, plugin code runs on the server. Authors declare which project kinds and platforms their packages support, and include the appropriate binaries when native dependencies are involved.

The Studio IDE also gains a Plugin Library, available across your solutions on the same computer. Import a package once, then select it for whichever compatible projects need it.

Versions can live side by side, and updating a project is an explicit choice. Installing a newer plugin doesn’t silently change an existing application. Your saved solution records the exact package versions and hashes it uses; when you move to another development computer, those same packages need to be installed there. The Using Plugins guide covers installation and version management.

Deployment was particularly important to me. Built applications carry their selected plugins and the required runtime dependencies. Someone using your application doesn’t need to install the plugin, Objo Studio, the SDK or a separate .NET runtime. They receive the application you built.

This first release focuses on non-visual application libraries. Custom controls for the visual designer and extensions to Studio itself are future work. There’s already plenty to explore here: document generation, specialist database access, image processing, existing business logic and native functionality exposed through a C# wrapper.

For plugin authors, the public SDK distribution includes the tools, a starter template and maintained samples. The documentation has both a step-by-step first-plugin tutorial and a guide to wrapping existing libraries.

Download the latest Objo Studio, try the samples, and let me know what you’d like to build on the forums.

Thank you to everyone who has kept asking for this feature and explaining what it would let them do. Those conversations helped shape the SDK, and I’m excited to see what you make with it.