Usually, but not always, compiling and installing software from source goes as follows
in the source directory. With some packages you'll need to run autoconf
or similar program first.
2) once configure successfully, I repeat, successfully finishes, issue
which should compile the program. If you'll want to "install" the program after this, i.e. put the files in correct directories, become root or use sudo
Specific instructions for every single package are found in somekind of documentation file, usually - yes, README
. After reading those you know how to install the software. If you didn't read them, it's your own fault -- you should
Instead of compiling programs from source it's, especially on Ubuntu, often easier to install binary (pre-compiled) packages. In your case it means using Synaptic
(graphical) or apt
apt-get install packagename
Synaptic is graphical and you'll probably figure it out yourself. Binary packages somehow correspond Windows installable packages, but not exactly. Their power is that most modern distributions, including Ubuntu, have package managers that not only install the binary packages but also handle removing them, updating them and automatically resolving dependencies
during the installation -- it means that if package1
to be installed before it can be installed, you can just tell the package manager to install package1
, it checks out what other packages it needs, fetches and installs them all in once. Nice, eh? Drawbacks: the software might not be the very latest all the time, since somebody has to compile and create the binary packages, and distribute them, before they can be used.
But as I said, if you just compile software from source, you have a lot work, managing the updating, removing and other actions isn't too easy (it's all manual work) and in case of compilation problems you'll have to spend some time figuring out what goes wrong. And if the program depends on other programs, you'll have to manually locate them, download, compile and install them in the correct order first. This is probably the main reason why binary packages and package managers exist today, even if compiling programs could make them a bit more efficent (they could be configured and tuned for the correct platform).