1.

Install dependencies GNUradio

apt-get -y install git-core cmake g++ python-dev swig \
pkg-config libfftw3-dev libboost1.55-all-dev libcppunit-dev libgsl0-dev \
libusb-dev libsdl1.2-dev python-wxgtk2.8 python-numpy \
python-cheetah python-lxml doxygen libxi-dev python-sip \
libqt4-opengl-dev libqwt-dev libfontconfig1-dev libxrender-dev \
python-sip python-sip-dev
2. git clone git://code.ettus.com/ettus/uhd.git
3. cd uhd/host
4. mkdir build
5. cd build
6. cmake ../
7. cmake -DENABLE_USRP_E_UTILS=ON -DENABLE_E100=ON ../
8. make
9. make test
10. make install
11. vi .bashrc
#tambahkan LD LIBRARY PATH UHD
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:usr/local/lib
12. sudo ldconfig

https://brmlab.cz/user/jenda/gnuradio
Install GNURadio ubuntu 14.04
## Ubuntu 14.04:
sudo apt-get install python-cheetah libboost-dev libboost-all-dev libfftw3-dev swig
# for GUI (optional)

sudo apt-get install libxml2-dev libzmq3-dev python-gtk2-dev python-numpy libxml+

+2.6-dev python-lxml\
libwxgtk3.0-dev python-qwt5-qt4 pyqt4-dev-tools python3-pyqt4 python-gtk2

git clone http://git.gnuradio.org/git/gnuradio.git

cd gnuradio/

git submodule init

git submodule update
cd volk
mkdir build
cd build
cmake ..
make
sudo make install
cd ../..

mkdir build
cd build
cmake -DENABLE_DOXYGEN=OFF ..
# There is currently conflict with UHD and Boost in Debian Sid. Use
-DENABLE_GR_UHD=OFF
# if you don't need UHD and have problems with linking.
make
# if you have enought RAM (8GiB +) you can make it much faster
# make -j 4
sudo make install
cd ../..

https://wiki.gnuradio.org/index.php/UbuntuInstall
Dependencies GNURadio Trusty Tahr (14.04)
sudo apt-get -y install git-core cmake g++ python-dev swig \
pkg-config libfftw3-dev libboost1.55-all-dev libcppunit-dev libgsl0-dev \
libusb-dev libsdl1.2-dev python-wxgtk2.8 python-numpy \
python-cheetah python-lxml doxygen libxi-dev python-sip \
libqt4-opengl-dev libqwt-dev libfontconfig1-dev libxrender-dev \
python-sip python-sip-dev
Then set the following environmental variable to use PyQT:

export PYTHONPATH=/opt/qt/lib/python2.7/dist-package

You can do this automatically via: build-gnuradio gitfetch. Or manually:

git clone --recursive http://git.gnuradio.org/git/gnuradio.git

or

git clone --recursive git://git.gnuradio.org/gnuradio.git

Configure and build GNU Radio:

cd gnuradio
mkdir build
cd build
cmake ../
make
Notes:

If you want to use GNU Radio with a USRP, see UHD instructions
By default GNU Radio will be installed under /usr/local - for installing in a
custom directory see this section
After successful build you should run the GNU Radio software self-check (does not
require USRP):

make test
If any test or tests do not work, GNU Radio might still function properly, but it
might be wise to look in the email archives for a fix or to write the email list.
If writing to the email list, please include the OS type, OS version, and CPU type
(e.g. via "uname -a"), anything special about the computer hardware, software
versions (gcc, g++, swig, sdcc, etc) and how installed (standard or non-standard
package, source). You can find some useful tips for asking questions under
Reporting Errors.

Now install GNU Radio for general use:

sudo make install

You are now ready to use GNU Radio. You can try to execute the dial_tone.py example
(/usr/local/share/gnuradio/examples/audio/dial_tone.py) or the gnuradio-companion.

III. Start the build process

To compile, there are 5 steps. Start by cd'ing to the gnuradio directory, then
complete the following commands (this works on most Linux-based or -related
distros):

$ mkdir build
$ cd build
$ cmake ../
$ make && make test
$ sudo make install
This will perform all configuration checks and select for build, test, and
installation all components that pass.
The autotools build chain (using bootstrap, configure etc.) was replaced by CMake,
in case you were wondering.
Common configuration options
The previous commands might work out of the box, but perhaps you have to tell cmake
more information to make it work.
Here's the most common switches:

-DENABLE_GR_XXX=ON This enables (or disables for =OFF) the GNU Radio component
named XXX. You might not need all of them, and this way, you can compile quicker.
-DCMAKE_INSTALL_PREFIX=XXX Install your stuff to XXX.
-DQWT_INCLUDE_DIRS=/usr/include/qwt5 On some distros, cmake has trouble finding
QWT. This solves it.
-DCMAKE_BUILD_TYPE=Debug This causes gcc to add debug symbols to all binaries.
Useful for debugging (otherwise, it decreases efficiency!)
If you use a cmake GUI, such ccmake or cmake-gui, it will prompt you with all the
options (no need to learn them by heart).

Dealing with Old Build Problems

1) Uninstall gnuradio (from the build directory):

$ sudo make uninstall

If you don't have the build dir for the current build, you have to manually remove
all GNU Radio related files from your install prefix (usually /usr/local/).

2) If you got the code through git, restore the original git files from any added
files during an old build:

$ git clean -d -x -f
Then you can configure, make, etc. Careful: this really nukes any changes you made.

Generating GNU Radio Documentation

By default, gnuradio will automatically build documentation if doxygen and xmlto
programs are installed prior to installing gnuradio, so make sure they are
installed in your system. Doxygen is used to build the gnuradio C++ API
documentation. The generated documents can be found and browsed at
docs/doxygen/html/index.html. The xmlto is used to convert the extra documentation
xml files (found in usrp, gr-trellis,..etc folders) to html files.

To generate the Python docs, you also need sphinx.

https://wiki.gnuradio.org/index.php/InstallingGRFromSource
Using the build-gnuradio script
If you're using PyBOMBS, don't use this.

The build-gnuradio is an install script for recent Fedora and Ubuntu systems
provided by Marcus Leech.

The build-gnuradio script has a number of options that we can use to install
different versions of GNU Radio. Just running build-gnuradio with no additional
options, it fetches/builds the latest released version from the 3.7 series.

Passing the flag -m will fetch and build master/HEAD.

Passing the flag -o will fetch and build the latest in the old 3.6 series.

For the impatient: open a terminal window, move to the directory you would like the
source files to be stored (e.g. 'cd src/'), remove old build-gnuradio file, and run
this command:

$ wget http://www.sbrac.org/files/build-gnuradio && chmod a+x build-gnuradio &&

./build-gnuradio
This downloads the installer (build-gnuradio) and makes it executable. It then
downloads and installs all dependencies, downloads both UHD and GNU Radio from Git
(which means it will automatically install the latest version from the 'master'
branch), runs the make process, and installs it on your system (a lot of this is
done silently, so if there's a lot to do for the script, don't be surprised if it
doesn't say anything for a while). In most cases, simply running the script will do
all you need to get a running GNU Radio system built from source. Also, you will
have all the source code lying on your hard disk and therefore available for future
modifications. It combines the flexibility of installing from source with the ease
of using binaries and is recommended for most users of Ubuntu and Fedora.

Thanks to Marcus Leech for putting this together and hosting it.