Are you worried about the security of your code? No longer want to rely on external sources for your Dart packages?

JetBrains Space offers a complete solution for private Dart package storage. Using it, you can securely store and manage your code and package dependencies, and let your team quickly access and share packages within your organization.

Whether you’re working on mobile, console, or Flutter projects, Space Packages makes it easy to store and share your Dart packages.

Read this article to discover how you can use Space Packages for your Dart or Flutter projects.

Why use Space Packages for Dart?

While Dart is currently used by only 9% of developers worldwide, Flutter, the cross-platform mobile framework built on top of Dart, is extremely popular, as confirmed by 46% of respondents to the State of Developer Ecosystem 2022 survey.

At Space, we recognize the importance of supporting popular package types and have added Dart to our list of supported packages, alongside commonly used types, including Container, Maven, NuGet, Python, Composer, npm, and even arbitrary files.

Using Space Packages as a part of the complete development platform, you will get:

• Easy setup: You can create a private repository, or easily migrate from GitHub, GitLab, or Artifactory.
• Packages integrated into your pipeline: Store your packages next to your source code and Automation builds, using a uniform interface, quick navigation, and a unified system of permissions.
• More stable builds: Benefit from immutable versions, easy configurable Gradle build caches, and caching unreliable repositories.
• Package sharing for any load: Space Packages are effective for both small teams and larger enterprises. Enjoy reasonable working time even with a high workload.

Get started for free

Store internal Dart package dependencies

You can use private Dart repositories in Space to store and share your custom packages safely, keeping your code accessible only to team members.

1. In your Dart project in Space, create a private Dart repository. Follow this guide to learn more.

2. Set up a Space Automation job to publish packages to the private repository. Find more details in this guide.

job("Build, run tests, and publish") {
    container(displayName = "Run script", image = "dart:stable") {
        shellScript {
            content = """
                dart compile exe .\bin\dart_package.dart
                dart test .\test\dart_package_test.dart
                dart pub token add https://dart.pkg.jetbrains.space/acme-corp/p/my-project/my-dart-repo --env-var JB_SPACE_CLIENT_TOKEN
                dart pub publish -f
            """
        }
    }
}

3. You can now reference packages from this private repository in your Dart projects.

Distribute Dart packages publicly

To distribute some of the internally stored packages publicly, create an additional public repository. To do so, you can use another Space repository as a target repository for publishing.

1. Create a public Dart repository, and ensure you have selected Public access. This will be our target repository.

2. You now need an access token for your newly created target repository. Open it and click Get Started. You’ll see a helper window with tips on how to connect to this repository.
3. Switch to Publish and click Generate write token. Copy the token to the clipboard.

4. Open the Settings page of your source repository.
5. Go to the Remote Repositories tab and add your target repository here.

6. For Authentication, choose Token and paste the token from step 3.

7. When you need to publish a package to the target public repository, go to the source repository, choose the package, and click Publish to remote repository.

8. That’s it! The package is now in the public repository.

Publish Flutter packages

The same usage scenarios apply to Flutter packages – they can be stored in the same Dart repository along with ordinary Dart packages.

The only thing worth noting here is that there are no official Docker images for Flutter. You can either use unofficial images in your Automation builds or create your own custom image. For example, a job may look like this:

job("Build, run tests, and publish") {
    container(displayName = "Run script", image = "cirrusci/flutter") {
        shellScript {
            content = """
                flutter test
                flutter pub token add https://packages.jetbrains.team/dart/p/sasmp/my-dart-repo --env-var JB_SPACE_CLIENT_TOKEN
                flutter pub publish -f
            """
        }
    }
}

The published Flutter package in a Space Packages repository will look like this:

Mirror pub.dev

If you use Space Automation to build your Dart projects, it makes sense to create a local mirror of pub.dev. It is a type of repository in Space Packages that works as a pull-through cache.  When a package is requested, Space first looks for the package locally and, if it’s not available, downloads it from a remote repository. Learn more.

We hope this makes it clear how Space Packages can help you manage and distribute your Dart packages more securely and efficiently. Whether you’re part of a small team or a larger enterprise, Space Packages can streamline your package management workflows and enable faster collaboration.

Get started for free

We’d love to hear your feedback on Space Dart repositories and Space Packages in general, so if there’s anything you’d like to share, please leave your comments below.

Do you use feature branches or Git flow to ensure code quality?

The powerful combination of JetBrains Space Git flow with TeamCity offers a complete solution to help you achieve better code quality and keep your main branch green with stable builds. 

Space provides you with Git hosting, code reviews, and quality gates, while TeamCity offers a build pipeline. The native integration between tools will save you time and effort by ensuring you have a complete and well-integrated flow with a unified UI. 

Adopting the Space Git flow with TeamCity is easy and allows you to keep your main branch stable while controlling changes automatically. 

In this blog post, we’ll introduce the combo of the Space Git flow and TeamCity, and guide you through the process of using it in your project.

Get started with Space for free

What Is the Space Git Flow, and Why Use it?

The Space Git flow is a branching strategy that is similar to GitHub flow, but with a greater emphasis on safety when introducing changes to the main branch and the ability to scale to large projects and teams.

Getting started with the Space Git flow is easy and doesn’t require going all-in, as you can mirror your existing Git repository without having to migrate, and you can switch back any time.

Using the Space Git flow integrated with TeamCity allows you to:

• Achieve higher-quality code and a stable main branch by configuring quality gates based on TeamCity build status for merge requests.
• Introduce a code review process your team will love, integrated with IntelliJ IDEA and available on the go with Space iOS and Android apps.

Read this article to learn more about the Space Git flow.

How to Use the Space Git Flow With TeamCity

Watch this 3-minute video to see how the combination of the Space Git flow and TeamCity works in a project:

Read on to learn about the flow in more detail.

Mirror or host your Git repository in Space

Start by creating bi-directional mirrors of your repository from GitHub or another Git service and link it to Space in a few clicks. 

You can also use Space to host your source code privately. If you host it in Space, you can take advantage of the web-based interface and JetBrains IDE integration for a seamless development experience.

Protect your main branch from accidental pushes  

To prevent accidental pushes to the main branch, you can set up branch protection in Space. This helps you protect repositories from unauthenticated commits, restrict who can push or merge changes into the branch, and prevent accidental branch deletion.

Once you’ve set up branch protection, the only way a change can make it to main is through a merge request.

Create a feature branch

To start working on a new feature, you’ll need to either clone the repository to your machine, or use remote development with the IDE hosted on a virtual machine in the Space cloud.

With the Space Git flow, you make changes in a separate feature branch and then request a code review before merging it back to main. From your IDE, you can make changes, add a commit message, and then push this branch back to Space. 

Create a merge request

Create a merge request to begin the process of moving your new code into main. You can do this from within your IDE using the native integration, or you can find your branch in Space and create a merge request from there.

You can create a title and description for your merge request and see the commits that will be part of it. The quality gates configured in Space require at least one person to review these changes.

Quality gates are a mandatory and customizable set of conditions that need to be fulfilled before merging. Apart from code reviewer’s approval, you can set up a Space Automation job and a TeamCity check as gates.

Space will require a review based on code ownership

In your repository, you can create a special file named CODEOWNERS that specifies who is responsible for specific folders and files. Later, you and your colleagues will have the option to select a code owner to review your changes as a part of quality gates.

Wait for your team to review the changes 

Now you wait for your colleagues to review the changes. They can add comments and suggestions, or they can simply approve the request. With turn-based code reviews, Space makes it easy for both the author and the reviewer to understand whose turn it is to take action.

Space allows you to collect your comments as drafts and send them in batches so as not to overload your colleagues with unnecessary notifications.  

After you’ve agreed on changes with your reviewer, you can proceed with merging them.

Ensure your build is green 

With Space and TeamCity, there are a few options that you can use to make sure your build is green before merging your changes. You can use either or both of them for extra security.

Run CI/CD checks

After you create a merge request, Space Automation and/or TeamCity CI jobs are triggered to validate the changes by building the code and running tests. As part of quality gates, the changes will be merged into main only if a CI/CD server can successfully build the feature branch. 

The checks can be set and completed by both Space Automation and TeamCity.

These checks, however, only ensure the new code is valid and integrates well with the main branch at the time of branching. With Safe Merge, validation is done by attempting to integrate the new code with the very latest code from the main branch.

Run Safe Merge 

You can use Safe Merge before merging the changes directly into main. Safe Merge acts like a time machine – it runs a preview of what your main branch would look like with the changes. 

This can be especially useful for large projects because while you were working on a feature branch, the main branch could have received changes that conflict with your work. Safe Merge allows you to catch these conflicts before actually merging the branches.

Space creates a temporary commit with the latest changes, which can then be used to perform the required quality checks using an Automation job or TeamCity build.

In TeamCity, you’ll see Space trigger a special build, and TeamCity will report the build status back to Space when it’s finished. The changes are merged into the main branch only if the build succeeds. Otherwise, the merge is rejected.

Using the Space Git flow together with TeamCity ensures that changes to your code base are always reviewed. And thanks to Safe Merge, you’ll always have a main branch that compiles and can be deployed successfully.

How to Get Started With the Space Git Flow and TeamCity

If you already use TeamCity, getting started with the Space Git flow is easy. 

• Create a Space organization to get started.
• Check out this step-by-step tutorial to configure Space Git flow and integrate it with TeamCity. 
• Request a demo to ask your questions or get help tuning the flow to your specific process.

Get started with Space for free

What do you think about the combination of the Space Git flow and TeamCity? We’d love your feedback in the comments below.

Do you strive to deliver quality code smoothly and steadily?

For development teams that practice a continuous release cycle, establishing a delivery flow can require significant effort when it comes to coordinating team members, setting up processes, and integrating multiple tools.

To reduce this burden, we’re introducing the JetBrains Space Git flow, a complete process that helps you achieve better code quality and keep your main branch green. Using it, you can focus on development while ensuring your main stays stable as you implement changes.

Space provides you with Git hosting, code reviews, quality gates, and a CI/CD service on a single platform. Implementing the Space Git flow in your projects is easy, allowing you to control changes automatically and keep your codebase production-ready.

In this blog post, we’ll discuss branching strategies, introduce you to the Space Git flow, and demonstrate how it can be used in a project.

Get started for free

Choosing a Branching Strategy

The branching strategy you select for your team affects your code safety, feature release frequency, and speed of delivery, making this choice crucial to your development process.

There are several branching strategies that teams commonly use, including Git flow, feature branches, and trunk-based development. Among these strategies, Git flow or variants thereof are the most popular approaches. Here’s a short overview of the most popular branching strategies.

Git flow

Git flow is a branching strategy useful for teams that have clear release processes and need to keep their production environments stable. The reliance on multiple branches and rules, however, adds a lot of complexity to the process. This can be overwhelming for new team members and can lead to conflicts because of the failure to comply with continuous integration principles.

GitHub flow

GitHub flow is a lightweight branching strategy well-suited to teams that practice continuous deployment. This strategy emphasizes collaboration, frequent releases, and a streamlined development process. Given its simplicity, GitHub flow works best for small teams and projects. However, as size and complexity increase, it can become challenging to manage changes across the entire codebase with this flow. 

Trunk-based development

Trunk-based development is a branching model where developers collaborate on code in a single branch called trunk. This strategy requires direct pushes to trunk and collaboration among developers to maintain a stable trunk branch. Since changes are continuously integrated into the trunk, there is a higher risk of introducing changes that can impact the stability of the entire system.

How to choose a branching strategy

Each strategy has its own strengths and weaknesses, and the best choice depends on the specific needs of your team, as well as factors such as the team’s size, development process, deployment frequency, and code quality requirements. 

Understanding the pros and cons of each strategy can help your team make informed decisions about which approach to use. While you can implement almost any flow in Space, we recommend that you consider employing a strategy native to it – the Space Git flow.

Introducing the Space Git Flow

What is the Space Git flow? 

The Space Git flow is a branching strategy that is similar to GitHub flow, but with a greater emphasis on safety when making changes to the main branch and the ability to scale to large projects and teams. In JetBrains, we use this flow for many of our products, including Space itself.

The main elements of the Space Git flow are outlined below. Though most of the items are optional, the more you implement, the closer you will be to having the best and safest flow possible.

Main branch

A single main branch is always production-ready – the tests are green, and all changes are verified. The main branch is protected, meaning direct commits are not allowed. 

Feature branches

Changes to the code are made in a separate feature branch. Always create your feature branches from main. 

Merge requests and quality gates

To merge changes from a feature branch into main, you create a merge request that must pass through quality gates. Quality gates, which can be customized to fit your team’s workflow, are sets of conditions that have to be met in order to merge:

• Approval in a turn-based code review. A reviewer comments on the code and passes the turn to the author to make revisions until the changes are finally approved by the reviewer. 
• A successfully completed Space Automation job.
• An external check, which passes if an external CI/CD service like TeamCity reports that the build is successful. 

Safe Merge

Safe Merge is an additional safety step before finally merging changes from a feature branch into main. Space creates a temporary merge commit with the latest changes from both branches and uses it to perform quality checks with an Automation job or TeamCity build. If the checks are successful, the changes from feature are finally merged into main. 

Release branches

If your project involves public releases, you should use release branches created from main. If necessary, last-minute changes are cherry-picked from main to a particular release branch.

Why use the Space Git flow? 

The Space Git flow brings multiple benefits to your team and the development process. You can even get a feel for these benefits without going all-in, as JetBrains Space can mirror your existing Git repository without having to migrate. You can switch back any time. 

Using the Space Git flow allows you to:

1. Configure quality gates to achieve higher-quality code and a stable, protected main branch, with:

• Safe Merge for feature branches.
• Code owners for mandatory reviews in critical code areas.
• Space Automation or TeamCity build status as quality gate criteria for merge requests.

2. Introduce a code review process your team will love:

• Review code from IntelliJ IDEA with its native Space integration.
• Perform code reviews on the go with Space iOS and Android applications.
• Keep your code reviews in order and up to date with a clear turn-based review model.

The Space Git Flow in Action

Let’s have a look at how you can use the Space Git flow in action. Here’s a short video that summarizes how it works when integrated with TeamCity:

Want to learn more? See how the Space Git flow works in more detail below.

Host or mirror your Git repository in Space

You can use Space to host your source code or mirror your repository from GitHub or another Git service in a few clicks.

Protect main from accidental pushes 

To prevent accidental pushes to the main branch, set up branch protection in Space and enable quality gates. 

Once you’ve set it up, the only way a change can make it to main is through a merge request.

Create a feature branch

To start working on a new feature, you’ll need to either clone the repository to your machine or use remote development with the IDE hosted on a virtual machine in the Space cloud.

From your IDE, you can make changes to your code in a separate branch, add a commit message, and then push this branch back to Space. 

Before merging it back to main, you will need to request a code review from your teammates. 

Create a merge request

Create a merge request to begin the process of moving your new code into main. You can do this from within your JetBrains IDE using the native integration, or you can find your branch in Space and create a merge request from there.

You can set a title and description for your merge request and see the commits that will be part of it. The quality gates require at least one person to review these changes. 

Space will require a review based on code ownership

In your repository, you can create a special file named CODEOWNERS that specifies who is responsible for specific folders and files. Later, you and your colleagues will be able to select a code owner to review your changes as a part of quality gates.

Wait for your team to review the changes 

Now you can wait for your colleagues to review the changes. They can add comments and suggestions, or they can simply approve the request. After you’ve agreed on changes, you can proceed with merging them.

You can manage code reviews in Space, from your IDE, or on the go with the Space iOS and Android apps. 

Ensure your build is green 

With Space, there are a few options that you can use to make sure your build is green. You can use both of them for extra security.

Run CI/CD checks

After you create a merge request, Space Automation and/or CI jobs are triggered to validate the changes by building the code and running tests. As part of quality gates, the changes will be merged into main only if a CI/CD server can successfully build the feature branch. 

The checks can be set and completed by both Space Automation and an external CI/CD service, like TeamCity.

These checks, however, only ensure the new code is valid and integrates well with the main branch at the time of branching. With Safe Merge, validation is done by attempting to integrate the new code with the very latest code from the main branch.

Run Safe Merge

You can use Safe Merge before merging the changes directly into main. Safe Merge acts like a time machine – it runs a preview of what your main branch would look like with the changes. 

This can be especially useful for large projects because while you were working on a feature branch, the main branch could have received changes that conflict with your work. Safe Merge allows you to catch these conflicts before actually merging the branches.

Space creates a temporary commit and triggers a CI/CD build in Space Automation or Teamcity. The changes are merged into the main branch only if the build succeeds. Otherwise, the merge is rejected.

Using Git hosting, code reviews, and CI/CD together in the Space Git flow ensures that changes to your application’s code base are always reviewed. And thanks to Safe Merge, you’ll always have a main branch that compiles and can be deployed successfully.

How to Get Started With the Space Git Flow

Starting with the Space Git flow is easy, as no migration is required. Just mirror your repository in a few clicks. You can always switch back at any time.

Ready to give it a try?

• Create a Space organization if you don’t have one yet.
• Check out this step-by-step tutorial to configure the Space Git flow using Space Automation or TeamCity. 
• Request a demo to ask questions or get help tuning the flow to your specific process.

Get started for free

What do you think about the Space Git flow? We’d love your feedback in the comments below.

One of the advantages of using Space dev environments is eliminating the need for an IDE warm-up phase, which can take up valuable time. With Space, you speed up the dev environment startup by creating a warm-up snapshot that contains project indexes and other data like project dependencies.

Today, we’re introducing changes to the configuration of warm-ups and disabling dev environment warm-up via Space Automation. You can now set up the warm-up in the project devfile.yaml, along with other dev environment settings.

Keep reading to learn what has changed and how to configure dev environment warm-ups with devfile.yaml.

Changes introduced to warm-up configuration

Before the latest update, the only way to get a warm-up snapshot was to run a special Space Automation (CI/CD) job. That was quite inconvenient, as it required setting up Automation for the project and configuring a job in the additional .space.kts file.

That’s no longer the case! You can now set up the warm-up right in the project’s devfile.yaml, along with other dev environment settings.

Regarding available functionality, warm-up in devfile.yaml is just as good as with the old configuration. You can:

• Provide a path to a custom warm-up script file or a number of shell commands.
• Disable indexing during the warm-up.
• Trigger the warm-up by Git push, run it on schedule, or manually in the UI.

The examples below show you how to create a warm-up snapshot with project indexes for IDEA 2023.1 and data created by a ./dev-env-warmup.sh script.

Deprecated way of configuring warm-ups

.space.kts:

job("Warmup data for IDEA") {
    # optional
    startOn {
        // run on schedule from Mon to Fri
        schedule { cron("0 0 * * MON-FRI") }
        // or run on every commit push...
        //gitPush {
            // ...but only to the main branch
            //branchFilter {
           //     +"refs/heads/main"
            //}
        //}
    }

    warmup(ide = Ide.Idea) {
        // path to the warm-up script
        scriptLocation = "./dev-env-warmup.sh"
        // use image specified in the devfile
        devfile = ".space/devfile.yaml"
    }
}

New way of configuring warm-ups

Dev environment configuration including the warm-up is provided in a single devfile.yaml.

.space/devfile.yaml:

schemaVersion: 2.2.0
attributes:
  space:
    editor:
      type: Idea
      version: '2023.1'
    # The warmup will run in the 'my-devenv-container' specified below.
    warmup:
      # The warm-up will run on schedule
      startOn:
      - type: schedule
        cron: '0 0 * * MON-FRI'
      # or on git push to the main branch
      #- type: gitPush
      #  branchFilter:
      #    include:
      #    - 'refs/heads/main'
      script: |
        ./dev-env-warmup.sh
components:
- name: my-devenv-container
  container:
    image: mycompany.registry.jetbrains.space/p/myprj/container/dev-image:latest

Actions you should take 

We are disabling warm-up via Automation, and the related jobs will no longer run. Don’t worry though – you can still use the warm-up snapshots created with this method. To keep your warm-up snapshots up to date, you should move the corresponding configuration from Automation to devfile.yaml as soon as possible.

As always, don’t hesitate to leave your feedback. Let us know in the comments below how you like the new warm-up configuration method or if you have any questions.

In 2022, Space grew as a complete development platform, seeing improvements in a variety of areas. We introduced the on-premises version, guest members, and file storage. We also expanded Space’s extensibility options, offering greater customization for teams, and implemented a variety of other features.

In this blog post, we will take a look back at our accomplishments from the past year and share our main areas of focus for the first half of 2023. We also invite you to check out our detailed roadmap to see what features we have planned and track our progress.

Explore the 2023 roadmap

Space 2022 Retrospective

In 2022, our main focus was on making software development with Space more enjoyable, flexible, and efficient. Our team delivered over 40 standalone features and a lot of enhancements to existing functionality. Listing all of them in this post would be overwhelming, so we want to give an overview of the top priority features that were added to Space in 2022.

✅ On-premises version – Released

Space On-Premises was introduced and released in 2022 after being in Beta for 6 months. During this time, we gathered your feedback, stabilized the installation process, and added new features. It’s now publicly available for anyone to download and try for free.

✅ Guest users – Released

We made it possible for you to work with people outside your company by adding guest users to Space. You can invite clients, freelancers, and other partners to collaborate on your project in one place, while providing limited access to your company’s resources and data. However, based on your feedback, we realized that there is a demand for guest users with more restricted access to your project in Space. With this in mind, we’re now working on light guest accounts with a more limited set of permissions.

✅ File storage – Released

We added a file storage feature to Space Documents, making it possible to upload personal files and all project-related artifacts like images, PDFs, and others. You can now share, preview, and download files from a single file storage space, and keep everything you need to work on your project in one place.

✅ Marketplace – Released

We also introduced Space Marketplace, where you can find and use applications created by others or even share your own apps. Apps are the primary way to extend the functionality of Space, allowing you to tailor the platform to your team’s needs and incorporate more advanced workflows into your development process. Space Marketplace is in Beta, but we plan to continue its development and add more apps for the public release.

▶️ New hosting regions – In development

We are seeing a lot of interest in Space from China and other countries from the APAC region. Adding new hosting regions is one of our infrastructure team’s main priorities. We’re working on this feature and planning to deliver it in the first half of 2023.

▶️ Video calls – In development

In 2022, we made significant progress on video conferencing in Space and were able to open a private Beta for peer-to-peer and group calls. However, there is still much work to be done. So, we plan to continue actively developing audio and video calls, both for one-on-one and group conversations. We expect to open a public Beta for these features in the first half of 2023.

▶️ Simplifying Space – In development

Our goal is to simplify your Space experience without compromising functionality. We’ve made huge progress towards this goal by introducing the new project-centered navigation to help you focus on your work for a given project. We plan to continue working to streamline your experience, so stay tuned for updates.

▶️ Integrations with TeamCity and YouTrack – In development

We’ve made good progress toward integrating TeamCity with Space. With the Safe Merge functionality, you can run automated checks in TeamCity and see the results in Space. We also managed to link Space commits with YouTrack issues.

We’ll continue working on these integrations, as we believe that we can dramatically improve the continuity of the user experience between the tools by providing a single solution to JetBrains users.

⏸️ Localization – Postponed

Unfortunately, we didn’t make much progress in this area last year. We had to make the tough decision to postpone this project, but we will get back to it as soon as possible. We understand that localization is important for many Space users, especially in certain regions. However, for the moment, we need to focus on making the platform more functional and improving features, performance, quality, and stability.

Space Q1–Q2 2023 Main Directions

The Space team adheres to the principle of dividing work into smaller chunks, which helps us stay flexible and quickly react to your feedback. With this in mind, we are limiting our roadmap to the next two quarters.

While our priorities from 2022 remain a focus for 2023, we will continue to listen carefully to your feedback and adjust our plans accordingly. We invite you to explore our detailed Q1–Q2 2023 roadmap.

Short on time? Check out this overview of our main priorities for 2023.

Delivering new features

We’re working hard on implementing new software-development features and enhancing the existing ones in the areas of code reviews and Git hosting, CI/CD, packages, and dev environments.

Another priority is expanding Space’s extensibility options to meet the needs of different teams.

We understand that project management and collaboration features are essential parts of software development. With this in mind, we’ll continue enhancing Space issues, documents, chats with video calls, search, and navigation.

To ensure a unified user experience, our team is also working on improving the Space mobile apps for iOS and Android. Our priority is implementing support for features already available on desktop and browser.

Space On-Premises

We’re actively working to offer simplified Space On-Premises installation options beyond Kubernetes.

We will also provide deployment instructions for various environments, including the AWS, Google Cloud Platform, and Microsoft Azure public clouds, and instructions for using Docker-Compose as a production option for small teams.

Simplifying Space

To help you to get started with Space more easily, we are working on migration paths from other tools and platforms, including issues, documents, and packages. We will also work on improving the entire platform’s onboarding experience.

Integrations with tools from JetBrains and other vendors

We will keep expanding and polishing the integrations with YouTrack and TeamCity. We intend to make it possible to link Space merge requests and deployments with YouTrack issues, provide better support for YouTrack notifications and add unfurls in Space chats, and improve the process for importing from issues YouTrack to Space.

We also aim to expand Space’s extensibility options to support integrations with tools from JetBrains and other vendors.

We invite you to explore the detailed roadmap and track our progress on this page:

Explore the 2023 roadmap

Space Q1–Q2 2023 Features

Here’s a short overview of the features that are currently our top priorities.

Git hosting and code reviews

We plan to implement hierarchical quality gates for flexible monorepo configurations, make it possible to review files and filter them by code owner, facilitate inviting teams as reviewers, and provide the options to manually mark files as read and track review progress based on files viewed.

Automation (CI/CD)

We are going to update the universal parameters engine, speed up the build process with cross-job caches, introduce the ability to build and publish file artifacts, and switch to a dedicated app for authorizing automation jobs. We will also work to enhance deployment targets with a new UI and API and support custom fields.

Packages

To top off our project of adding options for migrating from remote repositories for the most popular package types, we plan to implement support for Cargo packages. Our priorities also include improving the Packages web UI, adding support for granular permissions, improving the availability of the service, and implementing global search functionality for packages.

Dev environments

Our primary points of focus for dev environments are implementing dev environment support in Space On-Premises, adding the ability to pre-install IDE plugins, updating the warm-up list presentation and subscription mechanism, adding notifications, and allowing restricted access to dev environment configurations.

Extensibility

We plan to improve the SDK and introduce a synchronization API to allow updates of specific entities in Space, for example, to monitor issues in a project. We also intend to introduce a customizable webhook payload and implement versioning for our HTTP API.

Mobile apps

We plan to focus on complete support for code reviews and merge requests, as well as introduce the latest project and chat features and Space calls into the Space mobile apps later this year.

Issues

We are working on a global issue list and smart search functionality. We intend to provide time-tracking reports and a spreadsheet-style view with batch editing. We also have plans to improve the issue boards with manual backlogs, sprint improvements, and full-blown swimlanes.

Documents

Our main goals are to simplify onboarding in Space Documents, introduce search and navigation improvements, implement a new text editor, and add support for granular permissions.

Chats

We’re already working to improve notification settings and general performance. We also plan to add sticker and GIF support, as well as to improve the default functionality for postponed messages, and introduce an all-reactions view. We’ll continue our ongoing work on video calls, with the intention of opening the public Beta for them.

Full-text search and navigation

We’re working on revamping quick navigation in Space. Our goals are to speed up and simplify navigation, improve the sorting and grouping of items in the menu, and add a redesigned filter system.

What do you think about our roadmap? Let us know what features you are most excited about trying in the comment section below.

When using a version control system like Git, being able to explore the commit history is fantastic: you can see who and when made certain changes, and you can piece together how your code base evolves over time. Except, can you be sure the changes really were made by the developer the Git history shows? Anyone who has access to a Git repository can commit changes with any name and email address, so how can the commit history be trusted?

Signing Git commits is a way to ensure the authenticity and integrity of your commits. Doing so lets you prove that a commit was indeed made by you, and that the changes you’ve made to the code base have not been tampered with by anyone else. Other contributors will have peace of mind knowing it really was you, not some wannabe hacker. In addition, you’ll get a cool Verified badge in the commit history.

You can also configure your Git repository host to validate commit signatures when pushing changes. If an invalid signature is detected, or the key used for signing is not linked to a known user, the push can be rejected. This helps you ensure the security, authenticity, and integrity of your Git repository.

In this blog post, we’ll explore what signing Git commits is all about and how JetBrains Space can help you verify Git commit signatures. We’ll also provide some links and resources on how to get started with signing Git commits.

What are Git commit signatures?

When you sign a commit, you use a private key to create a digital signature for the commit. This signature is then attached to the commit and can be verified by anyone who knows your public key.

Signing Git commits helps with two important aspects of the software delivery lifecycle (SDLC):

• Security – By signing your commits, you can help protect your repository from tampering or modification by unauthorized parties.
• Authenticity – Git commit signing lets you verify the identity of the person who made the commit, and it helps ensure that the commit is genuine.

To sign Git commits, a GPG (GNU Privacy Guard) key or SSH key is typically used. Historically, GPG keys have been used for signing Git commits, but since Git 2.34, SSH keys can be used, as well. You can use your existing SSH authentication key as a signing key, or you can generate a specific one for commit signatures to make sure Git authentication and commit authenticity use different proof.

How to verify Git commits using JetBrains Space

JetBrains Space is a complete software development platform that lets you host Git repositories and helps teams work together more effectively. One of its features is the ability to verify Git commit authors and signatures.

To configure verification when pushing to a Git repository in Space, go to the repository settings and edit the Push restrictions.

There are several options when it comes to validating commit authors:

• Verify committer – Checks that the email address associated with the commit matches the person’s email address in Space. This check doesn’t add much in terms of security, but can be enabled to make sure the client is set up properly. For example, it can be used to validate that a company email address is configured, not a personal one.
• Require commit signature – Allows only commits that have a valid GPG or SSH signature.
• Verify commit signature – Checks commits for a valid GPG or SSH signature but does not require them. Signed commits with known keys are labeled as Verified, while unsigned commits or commits with invalid signatures are labeled as Unverified. In order to use this option, every committer must upload their GPG or SSH key and configure it in their JetBrains Space profile. Note that Space doesn’t support S/MIME.

A combination of the last two options provides the highest level of security.

Once configured, Space will enforce these settings when pushing to the Git repository. For example, when you configure the Git repository to require a valid signature and try pushing an unsigned commit, it will be rejected:

> git push
Enumerating objects: 4, done.
Counting objects: 100% (4/4), done.
Delta compression using up to 16 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 273 bytes | 273.00 KiB/s, done.
Total 3 (delta 1), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (1/1)
remote:
remote: b1f7d0f2b2857e16cd756ed9cdcca938b9aaa597: Commit is not signed
remote:
To ssh://git.jetbrains.space/demo/blossom/BookingService.git
 ! [remote rejected] main -> main (b1f7d0f2b2857e16cd756ed9cdcca938b9aaa597: Commit is not signed)
error: failed to push some refs to 'ssh://git.jetbrains.space/demo/blossom/BookingService.git'

Commits with a valid signature will be shown as such in the Git commit history in Space. Signed commits will be marked as “Verified”, while unsigned ones will have an “Unverified” label.

If you’re using IntelliJ IDEA or any other JetBrains IDE, signature information is also displayed in the Git tool window. When you are signed in to your Space organization using the bundled Space plugin, the Git log will show you information about the commit, together with its signature verification status.

Seeing that verified badge next to your name is pretty neat, isn’t it?

Setting up Git commit signing with GPG

To set up Git commit signing with GPG signatures, you’ll need both Git and the GPG command-line tool installed. You can run gpg --version in a command prompt to see whether it’s installed.

If GPG is not installed, you can do it manually:

• On Windows, Git for Windows bundles GPG. You can also install Gpg4win.
• On Linux, GPG can be installed using your package manager (sudo apt install gnupg on Debian/Ubuntu).
• On macOS, you can use Homebrew to install GPG (brew install gnupg).

After you have both Git and GPG on your device, you’ll need to generate a GPG key pair by running the following command:

gpg --full-generate-key

When prompted, select a key type, key size, and expiration date. It’s generally recommended to use the default RSA and RSA (default) options, a key size of 4096 bits, and an expiration date of at least 1 year in the future.

The tool will also ask you to enter your name, email address, and a passphrase for your key. The name and email address you enter should match the ones you use for Git.

Once the key pair is generated, you can view your keys by running the following command:

gpg --list-secret-keys --keyid-format=long

From the list of GPG keys, copy the long form of the GPG key ID you’d like to use. This will look something like 32FA0BE4567C9ABC.

To sign commits with your GPG key, you’ll need to tell Git which key to use. You can do this by running the following command, using the GPG key ID you just copied:

git config --global user.signingkey 32FA0BE4567C9ABC

Additionally, if you want to enable Git commit signing by default, run the following command:

git config --global commit.gpgsign true

You’re almost there! Any commit will now be signed using your newly created GPG key. However, you’ll still need to export the public key and make sure Space knows it. To export the public key, run the following command (again substituting the GPG key ID you copied earlier):

gpg --armor --export 32FA0BE4567C9ABC

Copy the entire key, beginning with -----BEGIN PGP PUBLIC KEY BLOCK----- and ending with -----END PGP PUBLIC KEY BLOCK-----. This key will need to be added to your profile in JetBrains Space.

That’s it! You’re good to go now, with an additional layer of verification for all your commits.

Note: If you’re using other Git hosts, upload your GPG key using the instructions for GitHub, GitLab, or Bitbucket.

Setting up Git commit signing with SSH

If you want to use an SSH key to sign your Git commits, you’ll also need both Git and the GPG command-line tool installed. See the previous section to learn more about how to install them.

Next, you’ll need to set the gpg.format option to ssh, and set the path to your SSH key with the user.signingkey option. Optionally, you can sign all Git commits by default by setting the commit.gpgsign option as follows:

git config --global gpg.format ssh
git config --global user.signingkey /PATH/TO/YOUR/.SSH/KEY.PUB
git config --global commit.gpgsign true

Make sure to also add your public SSH key to your profile in JetBrains Space.

Tip: If you’re using 1Password, you can use its embedded SSH agent to handle SSH-based authentication and signing for you.

Enable Git commit signing in the IDE

If you’re using an IntelliJ IDEA-based JetBrains IDE, you can enable Git commit signing per project in the IDE. Go to Settings/Preferences in IntelliJ IDEA (or whatever JetBrains IDE you’re using), navigate to Version Control | Git, and then click the Configure GPG key button.

In the dialog that opens, you can toggle commit signing, and choose the signature that the IDE should use when signing your commits:

When enabled, every commit in the IDE will be signed with the selected key. The state of the GPG signature will also be displayed in the Commit details pane in the Git tool window.

In summary

Signing commits is a way to verify the authenticity of a commit in a Git repository. It helps ensure that commits have not been tampered with, and provides a way to verify the identity of the committer.

Git repositories in JetBrains Space let you verify commits when pushing to the repository. There are 3 levels of verification available: verifying just the committer’s email address, requiring a signature, and verifying whether the signature is valid and linked to a known GPG or SSH key. A combination of the second and third options provides the highest level of security, even though it requires that every committer upload their GPG or SSH key and configure it in their Space profile.

Once set up, enjoy the Verified badge for your commits in the Git history, as well as the added security and verification provided by signing commits.

Give it a try with JetBrains Space and let us know how it goes!

Today, we’re announcing the general availability of Space On-Premises, a complete and secure software development platform fully managed on your side.

For the past six months in Beta, we have been gathering and processing your feedback. We would like to thank our early adopters for giving Space On-Premises a try, sharing their impressions and thoughts, and reporting issues.

Our team has stabilized the installation process, introduced more features to the On-Premises edition to match Space Cloud, and fixed numerous bugs. We’re happy to release the On-Premises edition out of Beta and introduce the latest version – Space On-Premises 2023.1.

Read this blog post to learn more about Space On-Premises, what’s inside, and how to upgrade from Beta.

Download now

Why Choose Space On-Premises?

Space On-Premises is a complete software development platform created for professional teams striving for full control over their data. It allows you to:

• Manage maintenance and upgrades on your side.
• Use flexible deployment options that fit your infrastructure.
• Start with a free plan for up to 10 members.
• Reduce costs by using one development platform instead of multiple tools.
• Maintain one well-integrated platform to power both your entire software development pipeline and team collaboration.
• Customize and extend Space to meet your specific needs, using a rich HTTP API, webhooks, and a client SDK.
• Rely on native integration between Space and your JetBrains IDEs for a seamless development workflow.

Space On-Premises Installation Options

Space On-Premises comes with two installation options:

• Space On-Premises for Docker Compose, perfect for a quick trial.
• Space On-Premises for Kubernetes, suitable for production installations.

Not sure which installation option to use? Check out this article to learn more about Space On-Premises for Docker Compose and Kubernetes.

How to upgrade from On-Premises Beta

Space On-Premises Beta is still ongoing and offers a free license valid until January 31, 2023. 

To upgrade your On-Premises Beta version to the latest 2023.1 version, follow these upgrade instructions.

Space On-Premises Pricing Plans

Space On-Premises is available in three plans, including a free plan for up to 10 members and paid plans starting from $25 per member per month.

Space On-Premises features are broken down by plan, similar to the Space Cloud plans. For more details on pricing plans, refer to the Pricing page.

Space On-Premises Features

We’re committed to providing Space On-Premises with the same features available with Space Cloud.

Most of the Space features that don’t require hosting on the JetBrains side are available in Space On-Premises, including:

• Git hosting
• Code reviews
• Integration with JetBrains IDEs
• Issues
• Issue boards
• Documents
• Package management
• Chats
• Mobile clients
• Desktop clients
• Team management
• Calendars

As for Automation, you can run CI/CD jobs using self-hosted and Kubernetes workers.

Dev environments are not currently supported, but we’re working hard to implement them.

What’s New in Space On-Premises 2023.1

Here’s a list of features available in v2023.1 that weren’t part of the Beta 2022.1 version.

Full Automation support in Kubernetes On-Premises

In addition to external workers, Space Automation now supports Kubernetes workers that let you run CI/CD jobs on on-premises Kubernetes. You can create them in your cluster on demand. Learn more about how to use Kubernetes workers.

Guest members in Space

With guest members, you can now bring people from outside your organization to collaborate in Space with limited access to your company data and resources. Invite customers, freelancers, and other external contributors to your project, and customize their access to your resources. Learn more about guest members in Space.

Safe Merge and Dry Run

Add an extra layer of protection to the main branch to ensure that a merge commit doesn’t result in failed builds. Integrate merge requests with one click using the fully automated Safe Merge feature. Configure built-in automation or external commit statuses (such as from TeamCity) to verify changes. Learn more about Safe Merge and Dry Run.

Swimlanes and customizable issue boards

Add swimlanes to your issue boards to speed up your workflow and differentiate tasks.

You can also customize the way your issue cards are displayed on issue boards. Select the attributes you want to see on each card, such as issue ID, due date, status, attachment preview, or other issue fields. Learn more about this update.

Expand Space with Marketplace apps

We’ve introduced a new way to customize Space to meet your team’s needs – Space Marketplace. Download applications for Space, create your own apps, and share them with other people.

Get started by downloading apps provided by JetBrains that allow you to enable Slack link previews in Space and synchronize your Space and Slack channels. Learn more about Space applications.

Manage and share Dart packages in Space

Space Packages now lets you create your own Dart repositories. Use them to store and share Dart packages for your mobile, console, or Flutter projects. Learn about how to publish and manage Dart packages.

App Authorization Playground

The Authorization Playground is an interactive way to learn how app authorization works. Use it to experiment with different authorization flows for your apps right in the Space UI. Learn more about the Playground.

More features

Yet more features are available in Space On-Premises 2023.1: 

• Enforce two-factor authentication for specific roles.
• View your Calendar as a monthly schedule.
• Print, archive, and delete Space documents and save them as PDF.

Learn about all the available features on the What’s New page.

Ready to give it a try? Download Space On-Premises and share your feedback with us:

Get started for free

Space, a complete software development platform, simplifies team collaboration to help make development more enjoyable. However, development often does not take place exclusively within a single team, or even organization. 

To provide more opportunities for collaboration, we’re introducing guest users in Space. You can now invite clients, freelancers, and other external partners to collaborate on your project in one place.

Guest users in Space have a special status, a customizable set of permissions, and limited access to people and data in your organization. 

Read this blog post to find out more about guests in Space and learn how to add and manage them for your organization.

Guest user permissions 

By default, guests do not have access to your organization’s resources. Instead, they need to be explicitly granted access to resources and features in specific projects and chat channels in Space. Guest permissions can be customized individually by project administrators.

Guest users do not have access to organization-wide features, including blogs, calendars, member profiles, organization details, working hours, locations, and others. Administrative permissions are also unavailable to them.

When granted access, guests can participate in your project on different levels – collaborating on documents and issues, reviewing code, or writing package and Git repositories. Guests can collaborate on your project using their web browser or the Space desktop, Android, and iOS applications.

Take advantage of the guest users feature to invite:

• Clients to keep an eye on the project, monitor its progress, and communicate with your team.
• Freelance developers to collaborate on issues, review code, and chat.
• Freelance marketers, designers, and other specialists to collaborate with your development team.
• Partners to work together on a joint project.

Other users will be able to identify guests by a special tag next to their name in chats.

How to add guest users to your organization

Invite guests

You can invite guest users into your Space organization by going to Administration and selecting the Guests tab. From there, you have a couple of options for completing the guest’s profile:

• You can generate an invitation link or send the guest an email by selecting Invite guests and specifying the project you want them to join. The recipient will be able to join your organization and fill out their own profile information. 

• You can also add a guest and fill out their profile information yourself by clicking New guest from the same tab.

Create guest profile

You can provide your guest’s name, add a profile picture, give them a username, and specify the date when they joined your organization. 

How to set up permissions for guests

After a guest user accepts their invitation, project administrators can set permissions for them on a project level. Go to <your project> | People | Guests and enable the features you want your guest to have access to. 

Guest permissions offer a wide variety of customization options, from allowing guests to view project details and communicate in chats to letting them actually collaborate on documents, Git repositories, code reviews, and issues.

Guest user pricing 

On the free plan, 1 guest user is available for free.

On the paid plans, guests are for free in a 4-to-1 ratio, which means you can have 1 free guest for every 4 active users in your Space organization. All additional guests beyond the free allowance are billed as full users. Learn more about Space pricing.

Support for guest users was one of the most requested features in Space, and we are happy to deliver it for you. Are you considering adding guest users to your project? Share your feedback and thoughts in the comments section below.

We’re excited to announce the winners of the Space Apps Contest!

First of all, we want to thank all of the Contest participants and everybody who voted for the “People’s Choice” award. During the Contest we had 534 registered users, 35 submitted apps, and 14 apps approved as finalists.

Since we closed app submission on November 7, 2022, our judges have been discussing the list of the winners – here it is!

First place

Winner – Checklist Buddy

The prize – $2,000 Amazon gift card

Second place

Winner – Telescope

The prize – $1,000 Amazon gift card

Third place

Winner – getEmoji

The prize – 1-year Space Org plan subscription for 20 team members and an invitation to the Space Insiders community

Special prize from the Space team

Winner – Issues Dashboard

The prize – Trip to the JetBrains office in Munich

People’s Choice Award

Winner – Telescope

The prize – 1-year All Products Pack subscription

Everyone who submitted a valid application will receive a 1-year subscription to a JetBrains IDE of their choice.

Final list of submitted, valid applications:

1. Small talks app
2. Wikipedia Link Previews
3. Checklist Buddy
4. Issues Dashboard
5. Vonjy
6. Galactic RSS (Beta)
7. HN Link Unfurlinator
8. Telescope
9. Voyager
10.  Next Holiday
11.  getEmoji
12.  Anonymous Bot
13.  RSSpace
14.  SummIt

We’ll contact the winners very soon to discuss the details.

Thanks again!

You decide which one of the apps submitted during the contest will win its author a 1-year All Products Pack subscription. Cast your votes by November 27, 2022!

Vote for applications!

All that’s required to vote is to be registered on JetBrains Marketplace.

We’ll announce the winners of the People’s Choice Award and the winners in all other categories on November 28, 2022.

*The winner of the People’s Choice Award will be determined based on the highest number of user votes collected via the Contest website.

Stay tuned!

This year, JetBrains partnered with Google Cloud and DORA to put together the 2022 State of DevOps report. We presented the key takeaways and discussed how to achieve successful software delivery and optimize operational performance.

Webinar agenda:

0:00 – Introduction

1:04 – Accelerate State of DevOps Report

2:42 – Measuring Performance

7:37 – Key Findings

14:02 – Topology of Organizational Cultures

15:30 – SLSA Practices

16:55 – History Preserved – Git repositories in Space

27:16 – History Preserved – Space Dev Environments

29:58 – Two Person Review – Code reviews in Space

39:18 – Two Person Review – Pair programming with Code With Me

41:25 – Centralized CI/CD – CI/CD with teamCity Pipelines

45:53 – Build Script – Kotlin scripts in TeamCity

52:46 – Prevent inputs/parameters/metadata

55:20 – Continuous code analysis – JetBrains IDEs and Qodana

58:22 – Operational analysis

1:01:14 – Summary and wrap up

Driving successful software delivery can be easy with the right tools! Explore JetBrains solutions to help you cover your entire DevOps pipeline.

Join us on Tuesday, November 15, 2022, 4:00–5:00 pm UTC for a free livestream where we will discuss the 2022 State of DevOps Report.

Save your spot

This year, JetBrains partnered with Google Cloud and DORA to put together the 2022 State of DevOps report. We are hosting a livestream to present the key takeaways and discuss how to achieve successful software delivery and operational performance.

In this livestream, we will:

• Introduce the report, along with some highlights from the newly released Accelerate State of DevOps Report from Google Cloud.
• Discuss the operational performance practices currently employed by JetBrains.

Webinar speakers:

• Nathen Harvey – Developer Relations Engineer at Google
• Maarten Balliauw – Developer Advocate at JetBrains
• Marco Behler – Developer Advocate at JetBrains

The livestream will be interactive and will feature a Q&A session after the discussion.