Projectile is a project interaction library for Emacs. Its goal is to provide a nice set of features operating on a project level without introducing external dependencies. For instance - finding project files is done in pure Emacs Lisp without the use of GNU find.

Projectile also tries to be practical - if some external tools could speed up some task substantially and the tools are available, Projectile will leverage them.

This library provides easy project management and navigation. The concept of a project is pretty basic - just a folder containing special file. Currently git, mercurial and bazaar repos are considered projects by default. If you want to mark a folder manually as a project just create an empty .projectile file in it. Some of projectile's features:

• jump to a file in project
• jump to a project buffer
• jump to a test in project
• switch between projects you have worked on
• kill all project buffers
• replace in project
• multi-occur in project buffers
• grep in project
• regenerate project etags
• visit project in dired
• run make in a project with a single key chord

The recommended way to install Projectile is via MELPA.

Just drop projectile.el, dash.el and s.el somewhere in your load-path. I favour the folder ~/.emacs.d/vendor:

(add-to-list 'load-path "~/emacs.d/vendor")
(require 'projectile)

If you're an Emacs 24 user or you have a recent version of package.el you can install Projectile from the Marmalade repository.

If you're an Emacs 24 user or you have a recent version of package.el you can install Projectile from the MELPA repository. The version of Projectile there will always be up-to-date, but it might be unstable (albeit rarely).

Projectile is naturally part of the Emacs Prelude. If you're a Prelude user - projectile is already properly configured and ready for action.

You can enable projectile globally like this:

(projectile-global-mode)

To enable projectile only in select modes:

(add-hook 'ruby-mode-hook 'projectile-on)

Since indexing a big project is not exactly quick (especially in Emacs Lisp), projectile support caching of the project's files. The caching is enabled on Windows by default, since on Windows native project indexing in Emacs Lisp is the only game in town.

To enable caching unconditionally use this snippet of code:

(setq projectile-enable-caching t)

At this point you can try out a projectile command such as C-c p f (M-x projectile-find-file RET).

Running C-u C-c p f will invalidate the cache prior to prompting you for a file to jump to.

Pressing C-c p z will add the currently visited file to the cache for current project. Generally files created outside Emacs will be added to the cache automatically the first time you open them.

If you want Projectile to be usable in every directory (even without the presence of project file):

(setq projectile-require-project-root nil)

This might not be a great idea if you start projectile in your home folder for instance :-)

If you don't like ido you can use regular completion as well:

(setq projectile-completion-system 'default)

You might want to combine default completion with icomplete-mode for optimum results.

By default, projectile always shows the path (relative to the project root). You can force projectile to only show the path to a file if there are other files with the same name:

(setq projectile-show-paths-function 'projectile-hashify-with-uniquify)

Here's a list of the interactive Emacs Lisp functions, provided by projectile:

If you ever forget any of Projectile's keybindings just do a:

C-c p C-h

If you'd like to instruct Projectile to ignore certain files in a project, when indexing it you can do so in the .projectile file by adding each path to ignore, where the paths all are relative to the root directory and start with a slash. Everything ignored should be preceded with a - sign. Alternatively, not having any prefix at all also means to ignore the directory or file pattern that follows. Here's an example for a typical Rails application:

-/log
-/tmp
-/vendor
-/public/uploads

This would ignore the folders only at the root of the project. Projectile also supports relative pathname ignores:

-tmp
-*.rb
-*.yml
-models

You can also ignore everything except certain subdirectories. This is useful when selecting the directories to keep is easier than selecting the directories to ignore, although you can do both. To select directories to keep, that means everything else will be ignored. Example:

+/src/foo
+/tests/foo

Keep in mind that you can only include subdirectories, not file patterns.

If both directories to keep and ignore are specified, the directories to keep first apply, restricting what files are considered. The paths and patterns to ignore are then applied to that set.

Projectile can be integrated with Helm via helm-c-source-projectile source (available in helm-projectile.el). There is also an example function for calling Helm with the Projectile file source. You can call it like this:

M-x helm-projectile

or even better - bind it to a keybinding like this:

(global-set-key (kbd "C-c h") 'helm-projectile)

Obviously you need to have Helm installed for this to work :-)

• Traversing the project directory programmatically (instead of using something like GNU find) is not very fast. On the other hand - it's portable. Unlike find-file-in-project, projectile's jump-to-file will work on any OS.
• Some operations like search(grep) depend (presently) on external utilities such as find.

Check out the Projectile's project page.

Check out the project's issue list a list of unresolved issues. By the way - feel free to fix any of them and sent me a pull request. :-)

Here's a list of all the people who have contributed to the development of Projectile.

Contribution is always welcome!

Install carton if you haven't already, then:

$ cd /path/to/projectile
$ carton

Run all tests with:

$ make

Bug reports and suggestions for improvements are always welcome. github pull requests are even better! :-)

Together we can create the ultimate project management tool for Emacs.

Cheers,
Bozhidar