As a developer, the tools you use day-to-day have massive implications for your productivity and the quality of the apps you create for customers. Better tools mean less time struggling with environments or working past limitations and more time building innovative features.
Forge reduces the effort and complexity needed to build powerful apps, but some parts of the developer experience still created friction. Over the past few months, we've been on a mission to fine-tune the frontend, the backend, and beyond, giving you a more powerful platform that makes it easy to build great customer experiences.
Today, we're excited to promote three major new features to general availability: the native Forge JS runtime, Forge remote, and UI kit 2. Now, developers get a runtime that's not just secure, it's also fast and compatible with the entire JavaScript ecosystem. On the frontend, UI kit is now not just easy to use, it also offers richer UI components and faster interactions. And with Forge remote, Forge now gives developers the opportunity to build exciting use cases on Forge by incorporating off-Atlassian services.
Here's a quick snapshot of the benefits for developers and the end users of your apps:
| New runtime | UI kit 2 | Forge remote | |
|---|---|---|---|
| Developer Experience | Eliminate compatibility issues and use any npm package or Node module, without sacrificing security | An expanded library of components, the same as those used by Atlassian products, to build consistently beautiful UIs. | Get greater flexibility to architect apps your way, by using Forge as your frontend with external backends. |
| Customer Experience | Apps execute 35-40% faster, giving your users a noticeably more responsive experience | New client-side rendering means user interactions feel faster and more embedded than the original UI kit | Give customers app features that rely on self-hosted AI models and services not yet natively available in Forge |
Let's get into the good stuff. In this post, we'll explain what you get with each of these releases and why they fundamentally improve the Forge developer experience.
Native JavaScript runtime
What if we told you a single line of code could make your Forge app 35-40% faster, provide compatibility with all Node modules and npm packages, and give you more available memory per invocation?
It's not too good to be true – the new Native JS runtime for Forge eliminates the friction of library incompatibility and allows apps to work faster. Now the default for all new apps, existing apps can upgrade to the new Forge runtime with a small modification to the manifest.
app:
runtime:
name: nodejs18.xFirst, a quick primer. Forge's original runtime was a sandboxed custom JavaScript environment that enforced strict data egress and tenant isolation – good for app security. But, it wasn't compatible with all Node modules – bad for developer experience. In the new Forge runtime, your app maintains the security benefits, but runs directly on a secure VM environment, running standard Node v18. This means the runtime behaves the way you'd expect, without the need for polyfills.
While many developers have been able to upgrade to the new runtime without needing to make any other changes to their apps, there are some limitations you need to be aware of (and of course, we recommend testing in a non-production environment first). Head to the docs to get started.
Forge remote
Forge allows developers to run apps entirely on the Forge platform, but there are use cases that require communicating with remote services. With Forge remote, Forge now supports use cases like connecting Forge to an existing application or invoking remote services not yet supported natively on Forge such as containers, RDBMS, or self-hosted AI models trained for unique use-cases.
Now, remote backends can store data in Forge storage and call product APIs via Forge. Forge can forward product events to a remote backend and invoke that remote service using scheduled triggers. And importantly, Forge provides authentication mechanisms to ensure these remote operations are secure.
It is worth noting that integrating remote services with Forge does shift more of the responsibility for security to the developer, and we still recommend using Forge-hosted storage and compute whenever possible. However, remote use cases are essential, and Forge now provides first-class tools to build them.
New and improved UI kit
UI kit is Forge's composable solution for creating your app's UI. With UI kit 2 – the next evolution of UI kit – you have 9 new components to choose from, access to more React features, and much faster user interactions compared to the original.
The biggest breakthrough with UI kit 2 is that work shifts to the browser so Forge doesn't need to invoke a Lambda function with every user interaction. This means UI kit 2 gives your customers a snappier, more enjoyable experience when using your app.
But it's not just about performance. With UI kit 2, you get more components and greater flexibility to build richer experiences for your customers. UI kit 2 aligns with the Atlassian Design System, the visual language used across all Atlassian products, giving developers an easy way to build rich experiences using the same components used by the platform. One improvement we're particularly excited about is support for XCSS, giving developers CSS-like control over component styling.
With this release, UI Kit 2 has been promoted to the latest version of UI Kit and will now be referred to as simply UI Kit.
| UI kit 1 | UI kit 2 |
|---|---|
| ✅ Platform-native components | ✅ Platform-native components |
| ⛔ Server-side rendering | ✅ Client-side rendering |
| ⛔ React-like features | ✅ Access capabilities directly from React |
| ⛔ 32 components, limited functionality | ✅ 37 new and improved components to create rich, interactive experiences |
| ⛔ Limited styling capabilities | ✅ XCSS support to style components using Atlassian Design Tokens |
Visit the docs to learn how to get started.
In case you missed it
Forge remote, the new runtime, and UI kit might be in the spotlight today, but they're not the only big things happening with Forge. Here are a few other notable Forge features that have recently shipped:
- Forge for Bitbucket: Now generally available, use Forge to extend and enhance Bitbucket, including custom merge checks.
- Export app metrics and logs to external tools:
- App Metrics API: Export your Forge app's metrics to popular observability tools like Datadog and SignalFX (these metrics are also available via a dev console dashboard).
- App Logs API (EAP): Stream app logs to export app logs to Splunk, Dynatrace, New Relic, or Datadog
- Build Forge-powered features on Connect apps: For partners with Connect apps today, you can now use Forge-only extension points, like custom fields, to build app features highly requested by customers.
- Data residency for Forge apps: Apps using Forge storage now pin in-scope app data to the same region as the host product, automatically. 13 regions are supported today, and Forge will support new regions as they are added to Atlassian Cloud products.
Stay up to date
With so many new features arriving in Forge, it's important to stay on top of new releases so you can be sure you're using the latest and greatest in your apps. If you haven't already, bookmark the changelog, where all new features are announced. If you want to see what's ahead, visit the Forge public roadmap.