Related
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 7 years ago.
Improve this question
I am aware of this question, but it is a bit old now, and some of the answers seem outdated.
Question: please write one answer per GUI you have used, including pros and cons (for example, as far as I can tell, with git gui, you can't manage the stash).
(This is not exactly a "Windows" standalone Git GUI, but still quite advanced)
Considering that since then, Eclipse is in the process of mirroring all its projects in Git repositories, EGit (based on JGit) have made some progress and are part of the Eclipse ecosystem, and is on par with its Mercurial counterpart.
You can contribute to EGit there.
This Tutorial is quite complete.
alt text http://www.vogella.de/articles/EGit/images/github60.gif
So far I've been happiest with Git Extensions.
Pros:
Fairly complete access to git commands
Doesn't hide git specifics like the index (unlike Tortoise)
Good branch visualization
Visual Studio integration in addition to standalone GUI or shell integration
Actively developed
Cons:
UI is rough around the edges in looks and usability.
As for the GitHub for Windows - I have used it for a little time and it's pretty nice. Very esthetic and quite straight forward. It's even better when working with repositories located on GitHub (however I used it with other targets as well).
Today I switched to completely new client for Windows made by Bitbucket named SourceTree. As I understand it's a port from Mac client and thanks to that it looks and feels great. It has LOADS of options and tools (I have not familiarized myself with many of them) and it's constantly developed ( http://blog.bitbucket.org/2013/03/19/introducing-sourcetree-git-client-microsoft-windows/ ). They released the Beta version on 19.03.2013 and they have some really nice plans for future (Mercurial support as well!). I do think that it's worth a look.
Have a look at Atlassian SourceTree. It's a free Git Client for Windows & Mac.
I'm using it since the beta. And it's really the best tool ive ever used for git in my opinion.
Say goodbye to the command line – use the full capability of Git and Mercurial in the SourceTree desktop app. Manage all your repositories, hosted or local, through SourceTree's simple interface.
More informations under:
http://blog.bitbucket.org/2013/03/19/introducing-sourcetree-git-client-microsoft-windows/
http://www.sourcetreeapp.com/
I've been using SmartGit for a few days now, and I have to say I'm very impressed. I'm not a git-genius, but so far I haven't had to break out the CLI for anything.
And the UI is just... pleasant, frictionless. There aren't any of the "couldn't they just have done this?" annoyances that I've found with others.
Another option now is http://windows.github.com/ Github for windows. But only really if you are syncing with GitHub. I've been using this for a few weeks, and I do find I need to fire up a shell from time to time. Its also unclear what commands its actually issuing. I keep ending up in the middle of a broken rebase - but I have no idea why its rebasing! But for frictionless use 99% of the time its great.
I've used the following
GitHub for Windows - required me to download installer which took a long time for me to install. UI was too basic for me and at that time was very slow even when using a local repository.
SourceTree - UI looks goods but under delivers on features when compared to GitEye and SmartGit.
Collabnet GitEye (site) - UI is famililar to Eclipse users just like me. Worked great and especially had a credential store (SecureStore) which inspired some confidence in how it handles storing of passwords plus SSH key management.
SmartGit (site) - offers personal and commercial versions but even the personal version is an absolute pleasure to use. Staging files, looking at logs, reverting, committing, pushing etc. The features were sufficient for me.
I'd recommend the last two especially SmartGit since the UI is user friendly and pushing to more than 1 repository is much easier.
My answer is not really that verbose but please try to download and see for yourself.
With visual studio there is http://gitscc.codeplex.com/ Git Source Control Provider which is a Visual Studio Extension. More into in this SO question Using Git with Visual Studio
I intend to use GitHub with Git Extensions and possibly integrate with FogBugz (optional).
Looking at the download page and reading some rather technical half related questions I wanted to see what you thought would be better to install on Windows 7, given I want to integrate with Visual Studio 2008 (thinking this would be through GitExtensions).
A straight answer (msysGit or Cygwin?) between the two would be great but any more no brainer advice on starting out on GitHub would be welcome, or if indeed I've missed the mark entirely (does it matter which?). Will be importing from Subversion.
Cygwin's was the officially recommended one last time I checked, but I think msysgit might have caught up now. I'm using TortoiseGit with msysgit, and it seems to work fine. Recommended.
In my experience, Cygwin is much better: Windows Git Tutorial: Cygwin, SSH and Projectlocker.
If you used TortoiseSVN with Subversion you might want to take a look at TortoiseGit, TortoiseSVN's Git version.
Git Extensions requires msysGit. The "Complete" installation has msysGit and KDiff3 packed with it.
As for the versus, the only major difference I know of is that msysGit doesn't support git-daemon, yet. Since you're using GitHub, this shouldn't affect you much.
Never found the previous options that great for Windows and had used mercurial for quite some time instead.
Now GitHub have done github:windows and after just a little use it is very impressive. It's a well thought out product and think will greatly extend GitHub usage on windows.
Assuming that I'm starting a new web project at home using Visual Studio, which version control system, viz. Git or Subversion will be better to use? Which one will have the least setup complexity?
Since this is for your own personal playing around, my question is simple: Do you know Subversion or Git already?
If you know SVN - use Git.
If you know Git - use SVN.
If you don't know either - use SVN. It's a better introduction.
I'd go with Git. It's not that bad getting up to speed on the basics (there are now a ton of good resources, including learn.github.com) and it'll pay off in spades. And I've been using it on Vista with no probs.
Subversion is far more Windows-friendly in my experience and also more immediately useful for the solo developer.
Another possibility is Perforce, which is slightly less Windows-friendly, but full featured and fairly easy to use, not to mention free for up to two users.
Git is a distributed source control setup and as you are the only user I can't imagine that you would benefit much from its features. Subversion is (in my opinion) easier to set up so I would recommend you go with it.
If you are working alone and want some kind of version control easy to use, then use Subversion.It works great on Windows, setting up the repository is one right click in an empty with Tortoise SVN. Ankh SVN provides a very good integration with Visual Studio - almost on par with TFS provided you use VS 2005 or more recent.
On the other hand, Git is much more promising than SVN. I'll check it during this year, but third party tools are not on par yet.
I'd go with Mercurial instead. It's supposed to be similar to Git (which I never could get running because of the Windows issue) and is really easy to setup in Windows & very nice for "personal" version control systems.
Which one you decide to use depends a lot on what your needs are now and going forward. Git has a very nice community built a round it with GitHub which is great for sharing code and projects. SVN is pretty simple to setup and get going, but in large teams Git has it beat hands down with it's branching and merging. This is ideal in cases where you have multiple people working on the same project, either in an office setting or an OSS sense where the team is spread out.
If all you need is something quick and simple to setup and get going so you can start your project, SVN should be fine. SVN is also integrated into many editors and IDE's as well as many bug tracking and continuous integration systems.
If you plan on having a team, or already do, Git is worth looking at for its branching and merging setup. Git however, due largely to still being kind of young, doesn't have nearly as much support available
If you want Visual Studio integration there is no question. Only Subversion has Visual Studio integrations (AnkhSVN, VisualSVN and several scripts that allow access to TortoiseSVN).
One of the most important reasons that Subversion has such a large amount of tools written for it is that it was designed as a stable library for use by multiple clients.
It's unlikely that Git gets the same level of integration in Visual Studio before git support is available as some kind of reusable library. (There are plans for a libgit2 that could make this a reality).
Let's my ride-in on your question and ask:
Does Git work on Windows?
Does it have something that's equivalent to Tortoise? (otherwise I don't see how it could compete with SVN in terms of ease-of-use)
On a side note: If it's really a one man home project, you don't really need any source control tool. Just put your project in a DropBox folder and you're done (auto-commits, infinite revisions, undelete).
Unless you really think you're going to need tags and branches and stuff. But for personal home projects... do ya?
You can make your own opinion after reading this : http://whygitisbetterthanx.com
Git................................(these dots are there because SO wont accept a 3 lettered answered).
A great answer to this question was recenting written about by Jack Repenning here:
If you have compelling requirements for a single, certain, master copy of your work, use Subversion. You can do this with Git, so long as there are no slip-ups. But you can’t do anything else with Subversion (slip-ups or no), and “compelling requirements” like Sarbanes-Oxley are happier with guarantees than possibilities.
If you plan to maintain parallel, largely shared but permanently somewhat different lines of the same product, use Git. One common example: perhaps you have a large product that you customize for each customer. The customizations are permanent, and generally not shared among code lines, but most of the code is common to all. Git was designed for just this case (in Git terms, local customizations to the common core, and occasional feature or bug-fix contributions back up-tree)
Neither of those? Take your pick, you should be fine with either tool.*
Full Blog Post here: http://blog.codesion.com/post/15692788883/subversion-or-git-decisions-decisions
With SVN you will have to set up a server, create a repository there, check out the (empty) repository, add your files, and then commit.
With Git, all you need is git init in your project's root directory. Then you can add and commit files as you see fit.
There's not really any idea in setting up a Subversion server, since you're the only one working on the source. Contrary to what many people think, solo projects is a perfect match for distributed version control tools. It's also very easy to grow your project later on.
In my experience, Subversion is easier to "grok", but Git is faster and easier to engage in software development best practices. As a former CVS user, Subversion made immediate sense to me when I started using it. Git took some study and I still have to refer to the manual from time to time, but I love how easy it is to branch and merge code when I've got to maintain a release process.
If you are already familiar with CVS and just need something to keep your history and diffs, Subversion will be easier to get started with. If you are new to version control, the tide is shifting toward DVCS in general and Git in particular, so you may get more mileage out of that in general.
I do recommend you look at a hosted provider so you don't have to worry about setting up a Subversion server or so you can have a backup location for your Git data. You can Google for "subversion hosting" or "git hosting" to see the premier providers in the space.
If you plan to take your project along on an USB stick, use Subversion. Windows XP it really, really, really bad at caching lots of small files on an USB stick. Git writes many small files for commit operations and that takes ages on Windows.
[EDIT] The problem with Windows XP and files on an USB stick is caching (or the lack thereof). To prevent data loss, XP will always write files synchonously on an USB stick (so any write will come back only after the FS has reported that all blocks have been written to the stick). Add that to the fact that USB sticks are slow when handling small files (they have a lot of overhead initializing their wear level management) which leads to very poor performance for any kind of application which writes lots of small files.
[EDIT2] If you put a SVN checkout on the USB stick, you will also have a lot of small files (especially in the .svn directories). So the solution in this case is to put the Subversion repository (the "server") on the USB drive. The repository uses only a bunch of big files (if you use the database option instead of the file based one: svnadmin create --fs-type bdb). This avoids the "many little files problem". There is no way to achieve the same thing with current versions of Git.
I am developing an application for the Mac as a small team (me + another person) effort. We are located in different cities, and have started to see the need for solid source control management.
None of us have any experience with this, and both of us are relatively new to Cocoa/Obj-C/Xcode (but do have C knowledge).
Does anyone have any recommendations as to which SCM system to choose? I understand that a lot of people are using Subversion, which is also supported in Xcode 3.1. Does anyone have experience with using Subversion through Xcode? Or is it a better option to chose a stand alone GUI alternative, such as Versions?
Grateful for any input on this.
Gregor Tomasevic,
Sweden
Update/personal experiences:
Since this post, we have tried Versions and Cornerstone (both of which are SVN GUI-clients), as well as Xcodes built-in support for SVN. We were not particularly pleased with Versions, which seemed to have some problems with committing unversioned files/build files. The built-in SVN support in Xcode works quite well, although it probably has limitations that we have still not run into. Cornerstone is both simple to use and powerful, and does not seem to suffer from the problems we encountered with Versions.
So far, we have just tried committing, updating repo, checking out latest/previous versions of our files and worked some with file comparison. It might be a whole different ball game once you start working extensively with branching, an area which we have been told both these GUI clients might have some weaknesses in.
For what it's worth (and with only days of evaluation) Cornerstone seems to be a somewhat better alternative, although for simpler SCM, Xcode works well too.
Thanks for all the comments.
Xcode only supports Subversion, Perforce, and CVS. However, there are also distributed version control systems out there, such as Mercurial, Bazaar, and Git. These have no Mac-native GUIs, but you should still consider them. Personally, I love managing my projects in Mercurial repositories.
[Added 2011-03-10] Xcode 4 adds support for Git. Several of us have filed requests for Mercurial support; you should, too, if you want it.
There is a nice GUI frontend for Mercurial on Mac called MacHG: http://jasonfharris.com/machg/
It is free and very nice IMHO.
You can't really go wrong with using Subversion.
If, like me, you don't like Xcode's SVN integration too much you can always choose to use the command-line tools, or one of the several GUI apps like Versions, CornerStone or SvnX. Most of these tools work together pretty well, so you're not necessarily tied in to the tool you start out with.
I personally do most of my work with Versions, and use the command-line tools with the same working copies every once in a while.
If you're comfortable working with command-line tools exclusively until someone creates a good GUI app around it, git is a pretty viable option too.
disclosure: I'm one of the people who work on Versions, so I might be slightly biased ;)
Xcode's Subversion support is pretty good. 90% of the SVN activities I perform are easily doable from Xcode. For the other few things I just fire up Terminal.
There are a couple things in their SVN client implementation that are annoying:
The code that checks to see which local files have been modified seems to run on a background timer, and its pretty latent. Sometime it takes 5 minutes for Xcode to show a file as modified. The same thing is even more exaggerated w/r/t remote modifications.
Sometimes when you rename or delete a file that isn't under source control, a dialog will appear, asking "Do you wish to [rename/delete] this file in SVN as well?" And the options are "Yes" or "Cancel." You choose Yes out of desperation only to be presented with a well-deserved SVN error.
Overall, I'd recommend it.
Caveat: If you simply tell XCode to add a project to a repository by giving it the top-level dir, it WILL add the build directory to the repository, which of course is a terrible thing to do.
In order to get around this you have to move the build dir to another location so that XCode won't try to import it, or manually add the discrete folders of a project one by one.
Subversion is the traditional OS X source control solution, in Leopard it's supported in Xcode and OS X, not to mention the third party GUI apps (a few of which look very slick). Despite all of this though, a lot of the independent OS X developers have switched to Git over the past year or two. As a single developer I can tell you Git has turned out to be a very good solution for me, and along with Github it makes a great solution for a small team effort.
If you're interested in using Mercurial on OS X, try SourceTree, it's not free but it's competitively priced and has a very polished Mac OS feel. I've been using it for personal projects for the last few months on and off and find it intuitive and reasonably robust.
It's available through the Mac App Store and supports Git and Mercurial. They have a website at http://www.sourcetreeapp.com/ with more information.
If your going for subversion, I've heard good things said about Springloops. I code together with some friends too in a similar fashion and we use Github. Git is such a wonderful experience. I don't use any GUI for it since I'm much more efficient with a shell prompt. But of course, I'd welcome if Xcode had support for Git repos.
Mercurial (like git) is "distributed" and perhaps regarded as more modern and up-and-coming than svn (but less established). If you want to auto-checkin using mercurial, you can add the line:
hg commit -m "Xcode auto commit"
as part of a "Run Script" stage of the XCode build, as found in:
Project > New Build Phase > New Run Script BUild Phase
I use : https://bitbucket.org/hsivank/xcode4-with-mercurial/wiki/Home
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 9 years ago.
I'm trying to find a source control for my own personal use that's as simple as possible. The main feature I need is being able to read/pull a past version of my code. I am the only developer. I've looked at a lot of different version control systems, but they all seem way more complicated than I need. I need one that's simple, runs under Windows, and doesn't expose itself to the network.
Specifically, the version control system should not require exposing an HTTP interface, it should interact with the local filesystem only. It just needs to be a version control system geared for one guy and one guy only. Graphical UI is a plus.
Does anyone know of software would satisfy what I'm looking for?
Thanks!
-Mike
Subversion is great -- you can run the server yourself or use something like assembla.com to host your code (although that exposes it to the network).
There are numerous gui applications like tortoise svn that would allow you to interact w/ the source control repo
From what I understand, and at the risk of sounding like a fanboy, you might want to consider a DVCS (distributed version control system) like git or mercurial. They essentially take away the central repository part, so it should be ideal to use when you're a solo developer.
Another advantage is that when you decide to add people to your one-man team, you don't have to set up a central repository. All they have to do is clone your repository and they're good to go!
If you're windows based and are used to a shell plugin like TortoiseSVN I'd pick mercurial. Their windows integration is just a bit better than git's, using TortoiseHg. The git counterpart (cheetah) is on hold at the moment, due to the developer getting sick and tired of all the demands people were making ;-)
If DVCS is too exotic for this situation you could always rely on SVN. I've heard good stories about the already mentioned VisualSVN solution. Install, make some repositories and go. Install TortoiseSVN for shell integration, or perhaps Subclipse or ankhSVN for eclipse and visual studio, respectively.
Note: I have not actually tried git or mercurial in a real life project, just some test setups. I now have a simple project WITH version control (using mercurial in my case), without having to have access to a central repository.
Sourcegear Vault is free for a single user and you can run both the client and the server on your own machine.
Subversion with TortoiseSVN.
Like all version control systems, it will sound reasonably complex when you start off, but it's really very simple once you get into it, works well for a single developer, and doesn't require any network access if you don't want it to.
Plus, it's free.
For what it's worth, you can use Subversion & TortoiseSVN without a server using file:/// URLs to connect to you repository. I've done this to create repositories on USB thumb drives that I can move from machine to machine.
Here's a nice write-up: http://www.fredshack.com/docs/tortoisesvn.html
I use the free (2 user?) licence of Perforce. Powerful, fast, and well documented.
I'm a very satisfied user msysgit for Windows. It contains a recent copy of git as well as a GUI, a shell and a history browser in a single install package.
No need for a server component and if you do decide to host it somewhere your repository is signed and cannot be modified by the hoster without you seeing it. Finally, moving the repo to a server is a easy "push" operation which keeps all of your history.
You really can't get much easier than VisualSVN for version control on Windows.
I like to use Google Code, even for my one man projects, as it provides a Subversion repository already set up. Also, the server is offsite, which protects against hard drive failures and other disasters.
You might find Mercurial to be pretty nice for that purpose. You won't have to set up a server and creating the repository is as simple as doing "hg init" in the directory where your work is.
All the previous suggestions are pretty simple, and I know cvs is a bit out of vogue these days, but I like to use it's local mode for a repository that doesn't even need a server to install or set up. The repository can be anywhere on your hard drive. I have mine on a memory stick to have access to it anywhere even without an internet connection.
The key commands are:
cvs -d:local:/full/path/repository init
to create the repository
mkdir /full/path/repository/project
to create the module, and
cvs -d:local:/full/path/repository/cvs co project
to check out a local version.
TortoiseCVS gives you your Graphical UI
Bazaar. See Bazaar in five minutes for a great start.
Whenever you save a file, run the $ bzr commit -m "Added first line of text" command, and it's all taken care.
If you edit over FTP, make the FTP folder as a drive or folder, and bzr update after the commit.
+1 for Subversion, for those not familiar with it I would recommend the SVN Book.
VisualSVN Server is a complete installer for Subversion Server on Windows.
VisualSVN is a Visual Studio plugin for Subversion integration.
You could go with Mercurial.
It's very easy to start working with and there's TortoiseHg which integrates nicely with Windows shell.
You don't need a server for it as it's a distributed version control system - you can hold a whole repository copy on a flash drive and push/pull changes from it.
If you wish, you can put hg in a web server mode that makes the repository easily accessible over http.
As opposed to SVN and CVS, it doesn't spread its metadata directories all over the repository. There's just one .hg directory in repository root.
I use it daily and love it!
I use Subversion and TortoiseSVN — both are free. Your repository can be on the local machine. You don't have to work over a network.
However, for disaster recovery or even simple machine fault, it's probably a good idea to store your repository on a different computer and also back it up.
You might want to consider using a third party service to host your repositories off-site over the internet. I use CVSDude and am satisfied.
I am also a lone developer, and I use Subversion and TortoiseSVN.
Setup of Subversion is quick and painless; it can be done in less than half an hour including setting up the repository.
There is no requirement by Subversion to run on a server, I actually run it on my local machine and keep my repositories on a separate drive. Connecting to the repository uses svn:// instead of http://. I'm not sure why you require that it does not expose itself to the network, but this would be a matter of security via obscurity. I'm sure networking experts could suggest better methods for locking it down, should that be necessary.
Once the repository has been created, commits and updates from the repository are as simple as right-clicking on a folder in Windows Explorer.
Any distributed revision control system is best for lone developers, like git or Mercurial. Best thing is you can incorporate more developers to your project seamlessly, as opposed to having to give them access to your main centralized SVN or CVS repository.
SVN and TortoiseSVN work for me. Definitely ensure you have offsite backup.
You might want to check out the wiki article Comparison of revision control software. A (slightly hard-to-read) comparison tool might help. You might enjoy If Version Control Systems Were Airlines.
I came here looking for the same thing, and I saw someone suggest Google Code. I tried it out, and it was brain dead easy to set up. Exactly what I was looking for. Works like a charm with TortoiseSVN (my favorite).
I came here for a solution, Google Code was all set up in about 2 minutes. You can choose SVN, git, or mercurial for your version control.
You should check CVSNT as server and use any of the clients you would like (standalone or integrated with your IDE). There are plenty of them.
Use Visual SVN to setup your server and then use Tortoise to access your repository. Both are free to use and we have been successfully using it for quite sometime now.
#gorgapor: Doesn't the Google Code TOS specify an open source license? It's not a generally applicable solution in that case.
I haven't seen anyone mention Perforce. Perforce allows you to use their software for up-to 2 users for free. You can run the server and clients in the same machine, which will give you the environment that you want.
This is much the same question as Source control system for single developer
The bottom line is: yes there is. More than one.
My opinion is that SVN will do just fine. it does for me in similar cases, as described here: Single serving source control
I have heard of a hosted Subversion vendor Versionshelf (http://www.versionshelf.com) on a podcast I listen to.
This site also has a list: http://snook.ca/archives/servers/hosted_subversion/