Other product variants may be available, please contact us or request a call back if you cannot see what you are looking for.

Product Information

TeamCity is a powerful Continuous Integration (CI) server designed for the .NET, Java and Ruby. Continuous Integration enables you to automate builds and get instant feedback on unit tests, code coverage, code quality and more. TeamCity enables continuous integration without leaving your favourite IDE - Visual Studio, IntelliJ IDEA or Eclipse. TeamCity is easy to set up so you can quickly improve your release management practices by gradually adopting its advanced features and capabilities.

New Features

New in version 7

• Build agent pools - organise build agents in pools and assign them among divisions or project teams or assign them based on the priority of your building tasks.
• Extended build chains support and visualisation - takes build chains support even further, providing an insightful overview of the completed and running build chains, with all the effective builds and their statuses.
• Incremental builds - new option that allows you to re-build and re-run only those modules and tests that are affected by the changes in the build.
• Build parameters with custom UI - specify a certain type for any custom parameter you define in either build configuration or the project. Based on this type, the Run Custom Build dialog will present a specific UI control for this parameter, be it a text field, checkbox, select, or password input.
• Build failure conditions - mark builds as failed on metrics change or on specific text pattern occurrence in the build log.
• Performance monitor - trigger performance monitor and have detailed information on hardware resources utilisation at each step of your build process.
• Branch graphs on change log - interactive branch graphs on the change log page provide clean and accurate reading of all branches and commits.
• ReSharper inspections - ReSharper Code Analysis helps you detect problems in C#, XAML, XML, and ASP.NET code.
• NuGET support - comes with an extensive NuGet integration, supporting the following scenarios: installing and updating NuGet packages on agents, creating, and publishing package to a given NuGet feed. TeamCity 7.0 can also act as NuGet feed server, and trigger builds on changes in a specified NuGet package.
• Rest API - now supports the ability to manage projects, build configurations and VCS roots remotely.
• Updated bundled software and compatibility - bundles with Maven 3 in addition to Maven 2. You can always select which Maven version to use in Maven build step, plus TeamCity is now fully compatible with Subversion 1.7.
• 'My Investigations' notification - a small counter near your name in the top right-hand corner shows you the actual number of problems assigned to you.
• Artifact browsing within archives - now you can also browse within archives.
• Redesigned admin area - reorganised to make it more scalable and easier to use.

Features

Continuous integration

• Remote build run and pre-tested commit - build, check and run automated tests on the server even before committing your changes - keeping your code base clean at all times
• Manual and automatic build triggering - run builds manually or automatically based on schedule, upon VCS check-in or upon another build's successful completion
• Notifications - get notified about changes/problems via web-based dashboard, IDE plugins, e-mail, XMPP, RSS and more
• Test reporting - track running tests and report all the information on the fly - both in the web UI and in all supported IDEs
• Risk group test reordering - instruct TeamCity to run tests of a specific type before any others
• Monitoring - get quick and accurate information about how well your recent changes integrate into the project
• Newly failed tests - for a failed test, you can see the build in which it failed for the first time with a link to changes in this build.

Quality tracking

• Analysis of unit test coverage - for Java, TeamCity comes with two coverage engines: IntelliJ-IDEA-based and EMMA, for .NET, TeamCity integrates with NCover and PartCover
• Server-side inspections for Java, JSP, JavaScript and CSS - TeamCity uses a set of more than 600 IntelliJ IDEA's inspections to analyse your code and identify potential problems
• Test result analysis - investigate which tests/classes/packages take most time to build
• Search for duplicate code in Java and .NET - the search for duplicates is performed on Build Agents and detailed reports are then available in the web UI
• Comprehensive statistics reports - track the condition of your projects over time.

Build management

• Build progress - conveniently evaluate build progress and current state from a number of different places
• Build configuration templates - save a lot of manual work when you need to define a number of duplicate or very similar build configurations
• Build tags, pins and comments - organise your builds and quickly filter builds in the build history
• Build history - keeps a history of builds' artifacts and other data such as build logs
• Custom and history builds - choose any change from the change history, and run a build that will not include any later changes
• Change log - accumulates the list of pending changes, and the changes already included in the builds of the selected build configuration
• Build chains and enhanced build dependencies - specify snapshot and artifact dependencies for your builds.

Build infrastructure

• Multiple build agents - TeamCity server distributes builds to the Build Agents automatically, without the need to install version control software on all of your build agents
• Load statistics matrix - provides you with a bird's-eye view of the overall Build Agents workload for all finished builds
• Build agents' workload statistics - provides a number of visual metrics, namely, statistics of Build Agents' activity and their usage during a particular time period
• Multi-platform builds - support for different platforms, operating systems and pre-configured environments that you may want to test your software on
• Assign builds to a particular agent - any build configuration can be explicitly assigned to run on a specific Build Agent
• Parallel build execution - start off a build on several compatible agents simultaneously
• Build infrastructure utilisation optimisation - you can always check your builds queue and see the estimated start time for any build

VCS interoperability

• Flexible configuration - use several different VCS roots for a single build
• File diffs on the web - view file differences on the web just like in the IDE and navigate to the project source base from the web
• Advanced VCS build triggering - scans all of the build configurations' VCS roots and triggers builds if changes are found
• VCS labelling - optionally add a label into Version Control for the sources used for a particular build
• Agent-side checkout - TeamCity checks out all sources on server and then passes them to agents before each build.

Key integrations

• Amazon EC2 and virtual agents - take advantage of cloud computing by putting Build Agents on Amazon EC2
• Issue tracker integration - issue tracker integration provides an in-place bug title, direct navigation to the issue, and other productivity goodies for Jira, Bugzilla and YouTrack
• Maven integration - TeamCity has many means for native Maven support under the hood.

Extensible and customisable

• Display custom build results - change the build status directly from the build script. You can set the status (build failure or success) and change the build description text
• Custom test runner support - create your own statistics graphs with simply providing the required data in XML configuration files
• XML reporter - process various XML reports and feed data to TeamCity
• 3rd party HTML reports - if your reporting tool produces HTML reports, you can easily add a new tab to the Build Results page that will display the report
• Plugin development - TeamCity functionality can be extended in a number of ways.

And more...

• JVM crashes and out of memory problem detection - detects crashes of the JVM and Java out of memory problems
• Hanging build detection - assist you with abnormal build detection and troubleshooting
• User authentication - supports NT authentication and LDAP authentication
• Thread dump for running builds (.NET and Java) - obtain a thread dump of your running build for investigation
• User management with pre-project access and roles - TeamCity users can be organized into groups and assigned privileges
• Audit of user action - logs user actions into the Audit log.

Editions

The Enterprise edition allows unlimited user accounts and build configurations ( whilst the free (Professional) edition allows only 20 ).