Plastic SCM features


Plastic SCM has been crafted to be the best fit for task-driven development. We support any branching pattern, but strongly recommend a branch-per-task approach.
Read more about task-driven development and its benefits.


Awesome branching and merging

Lightning fast branches

Branching is a very efficient process, so you can easily work with feature branches or go even further and use task branches, the model we recommend.

Task driven development

In task-driven development, changes made to individual files are grouped into higher-level structures, called tasks. Every change made to implement new functionality or fix a bug is a task.

Plastic SCM implements task-driven development efficiently and intuitively, through the well-known branch-per-task pattern. Read more...

Powerful merge

The merge backend will smartly reconcile the changes that you made with those of your colleagues.

Code that has been moved as the result of a refactor is detected and that information is used to ease the merge for the user. Complex refactor merges become trivial thanks to the “similar code” detection. This is our unique Xmerge technology.

Visual merge tools

Our algorithms will merge your changes between branches automatically most of the time. When a case arises where two developers touched exactly the same lines of code, our tools make it easy to solve the conflicts visually.

To better understand what changes are being merged, you can also visualize their relationship in the branch explorer.

Fully distributed

Clone branches

Replicate code branches from the repository on your laptop or between distant offices.

Lightweight server

Installable on laptops with an embedded database or in the central office server with corporate databases.

Integrated code review

Plastic SCM has it's own light code review system. It's distributed as well, so you can work on that offline and push your changes when you get connection again.

DAG core

In 4.0 we moved to a more "changeset centric" way of thinking, basically moving our "dynamic DAG" to a "pure DAG" repository model, making replica faster, easier and more robust. Cloning branches, working in parallel, reconciling remote conflicts, or inspecting remote changes are seamless and efficient operations.

Server profiles

You can connect to as many different servers as you want from your Plastic SCM client. It will manage the credentials needed for each of them and automatically choose those needed.

Synchronization view

The new synchronization view lets you configure your relations with other servers and replicate with a single click all the changes, so all the servers contain the same changesets. Robust, clean and efficient.

Transparent SCM

Changes detection

You don't need to worry about moving or renaming files and losing the synchronization with the version control. With Plastic SCM 4.0, you work with your files, change them, move them around, create new ones or even remove them. When you are ready to check your changes in, just go to the pending changes window. Plastic SCM detects all those actions and records them to the repository with a single click. It's transparent version control.

Checking out is no longer needed

With transparent SCM, you don't need to tell Plastic SCM when you change things. Just edit your code, move or delete files, and Plastic SCM will detect the changes for you.

For those situations where don't want anybody else to touch your file while you are changing it, you can still check it out exclusively.

Distributed Branch Explorer

Distributed branch explorer, more that 100 new features

Let us draw it for you

The branch explorer is a representation of the changes made in your project. It's a diagram that depicts branches' relationships and evolution in time.

In Plastic SCM 4.0, it becomes more distributed and aware of remote repositories. It's easier than ever to explore the distributed repositories of your collegues and replicate back and forth from them.

This 5 minutes video summarizes the features of the Distributed branch explorer:

See where changes come from

The branch explorer can assign different colors to the source of each changeset. It's easy to view in which server changes were made.

Visualize merge contributors

Before merging branches, you can now visualize the contributors on a reduced version of the branch explorer. Only the branches involved in the merge are displayed.

View remote changes before replicating

Browse remote changes made by your colleagues on their repositories. Just connect them to your branch explorer, they are drawn with dashed circles.


Focus on the interesting bits. Reduce the clutter by selecting the branches you want and display them alone in a separate branch explorer window.

Display only relevant changesets

Read between the lines. You can now filter out changesets not involved in merge or branch operations.

Relayout branches

Move branches up and down in the diagram to fit your needs if the default branch explorer layout doesn't.

Visualize your distributed development

Diff branches, changesets, labels

Focusing on what you've changed is easier than before, just diff a cset and quickly understand what you changed.

Tabbed interface

All the windows inside the GUI are now organized in tabs, for a more streamlined experience. In addition, some operations like merge are non-modal so that other windows can be used at the same time.

Components: delivered

Introducing Xlinks

Xlinks let you mount a code repository in a specific version in your workspace. Imagine you need to reuse a library from another project. Just create an Xlink in your workspace and your project now has a directory pointing to the specific version of your component. Could not be easier!

Read-only vs writable Xlinks

Sometimes you want to use a stable version of a component. For those, we provide read-only Xlinks and we ensure that you cannot change the mounted component.

But sometimes you need to modify the reused component. Writable Xlinks let you make changes in the mounted component, expanding the branch used in the "top" repository to the mounted component repository. These branches are later merged and Xlinks pointers correctly updated for your convenience, making component maintenance a breeze.

Integration with other systems


Plastic SCM integrates with the most popular software development IDEs like Visual Studio and Eclipse.

The integration with Visual Studio 2008+ lets you access all the windows of the Plastic SCM GUI client right from within the IDE.

With the transparect SCM features, you can seamlessly work even with IDEs that are not integrated at all.

Task and issue tracking

Plastic SCM really shines when used for task-driven development. Accordingly, the ability to integrate with issue tracking systems is an important aspect of the product architecture. Plastic SCM offers out-of-the-box integrations with several systems...

Integrations with task and issue tracking tools.
Continuous integration

Cruise Control, FinalBuilder, Zutubi's Pulse, Hudson/Jenkins and JetBrains TeamCity are some of the CI servers Plastic SCM supports out of the box.

Windows Explorer integration

You can use most of the features of the Plastic SCM GUI client from the Windows Explorer. All the views and common operations like checkin, add to source control and others are a right-mouse-click away.

Image preview and diff

For gaming developers

Specially designed for the developers in the gaming industry, we’ve greatly improved the image handling capabilities inside Plastic:

  • New image preview on the items view, so game designers don’t have to open the file to know what it is about. It is fully customizable so it can deal with every format.
  • Redesigned image diff with more capabilities to find what has been modified between two versions of an image.
  • It reuses the image reading capabilities added to deal with previews, so it is able to deal with virtually every format.


ACL based security

Every object in Plastic SCM has an Access Control List (ACL). The permissions it describes are inherited, both through the file system hierarchy and through the repository hierarchy.

SSL communication

We support SSL encrypted communication for increased security out of the box. Just specify "ssl://" in front of your server, and use the SSL port (8088 by default).

Active Directory and LDAP

Plastic SCM can authenticate users from LDAP or Active Directory, or from Plastic SCM's own username/password database.

Single port operation

Plastic SCM uses a single TCP port for all the communication between client and server. Easy configuration and administration.

Method history

We estimate that 95% of the time that you go through a file's history, it's to check a specific method.


4.1 introduces the best possible “shelve feature”: a mix between traditional “shelving” and cutting edge stash (git’s style). The new shelve is able to:

  • Save in progress work on your server
  • Merge it back (not only restore, merge!) when you need it


Admin improvements
  • Administration tool includes authentication provider migration wizard.
  • Database prefixes now supported
  • Caching of recently used trees on server
  • cm iostats as diagnosis tool
  • plasticlogstats reporting tool
  • New "code review" triggers
  • New delete changeset trigger
Xdiff and Xmerge

Xmerge and its close relative Xdiff identify fragments of code that have been moved within a file, linking them for easy navigation. They identify similar fragments of code (within a user-settable threshold), so that even if a code block was both moved and changed, it's recognized as the same block.

Code reviews

Plastic SCM's has an integrated code-review system (no need for a separate tool) that enables developers to enter line-by-line comments, and organizes the comments by branches and changesets (the natural units of change). It's the first distributed review system ever!

User defined attributes

You can create your own metadata in the form of name/value pairs, attaching it to any object in the repository. This enables you to create sophisticated reports, using data retrieved by SQL queries.

Database backends

Plastic SCM stores all data and metadata using standard relational database backends. We didn't try to reinvent the wheel, and we won't force you to abandon the storage solutions in which you've placed your trust (and investments!)

MS SQL Server, MySQL, Firebird, SQLite and Oracle are supported. PostgreSQL is in beta as well.

Exclusive checkout (locking) for unmergeable files

We always prefer merge better than locking. But some projects dealing with binary files (gaming, avionics, healthcare) have to cope with the un-mergeable contents. Then they need to “lock” before editing.

We make “exclusive checkout” (or locking) possible in the new release 4.1, and the breakthrough is that we do it even on distributed environments! No other DVCS can do that.

Plastic SCM now speaks Git

Plastic SCM is a full featured DVCS and now speaks the git network protocol.


Repositories that stores large binary files (for example, multimedia content) can grow rapidly. Archiving allows you to move old revisions files to backup storage, saving valuable server storage and can be retrieved later when they are needed.

Multiplatform support

Plastic SCM runs on Windows (XP or higher), Linux (including Ubuntu, RedHat, Suse, OpenSuse, Fedora, and many more), and Mac OS X 10.5 on Intel.

Proxy Server

Want to work from distant sites against a central server, but don't want to use distributed development? You can easily install a proxy server to cache data, greatly reducing network traffic and improving speed.

Audit for compliance

We’ve added auditing capabilities to facilitate compliance with policies such as the Sarbanes-Oxley Act.

Plastic SCM uses automation and auditable change tracking to help eliminate human error and criminal intent within the software development process.

Tuned merge machine

The merge system is the one of the core reasons to adopt Plastic SCM. Now it is stronger than ever.

Xlinks concept diagram