Skip to content
Scout -- Domain Specific Language & Toolchain
C++ LLVM HTML Assembly C Objective-C Other
Branch: devel
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Type Name Latest commit message Commit time
Failed to load latest commit information.
docs Fixes #24 -- bad mesh decls. Jun 27, 2015
emacs A few tweaks to the scout emacs mode. Nov 14, 2011
include disable bool vectors for now Feb 16, 2016
legion legion CMake updates Oct 23, 2015
lib Merge commit 'a811d6e0da285ca61f7ab4bb97180534c6e0dc26' into devel Nov 23, 2015
llvm Merge commit '736bb303e87df5810d8d65b6c41682ef108adb06' into devel Feb 17, 2016
sublime Some clean up of duplicated files (in git-tools and tools). Nov 10, 2013
tools merging w/ llvm/clang Feb 16, 2016
.project add eclipse project files Mar 5, 2014
CMakeLists.txt bump required cmake version to sync with llvm Mar 31, 2015 update LACC Aug 5, 2015
License.txt update LACC Aug 5, 2015
Makefile updates for Qt 5.5 Feb 18, 2016 update LACC Aug 5, 2015

Scout: A Domain-Specific Language & Toolchain

Welcome to the Scout Project!


Scout is a proof-of-concept domain-specific language for exploring the combination of mesh-based scientific computation and in situ data analysis and visualization. The toolchain is based on the LLVM compiler infrastructure, including the Clang front end, and the LLDB debugger. More specifically, the language extends the C programming language to introduce mesh constructs and various supporting constructs. n

The Scout Programming Language

The Scout toolchain is still very much a work-in-progress and the documentation and source are both under active development. We use 64-bit Mac OS X 10.9.X and Linux systems (primarily the LTS releases of Ubuntu / Linux Mint) as our primary development platforms.

Scout is open-source software (released under LA-CC-15-063). Los Alamos National Security, LLC (LANS) owns the copyright to Scout. The license is BSD-like with a "modifications must be indicated" clause. See the LICENSE file for the full details.

NOTE: Scout is still very much a work-in-progress and the documentation and source are both under active development. We use Linux-based systems and Mac OS X 10.9.X as our primary software development platforms with a range of supported GPU architectures. For CPU architectures we primarily support x86 systems but have recently added support for ARM-based platforms. More details on specific hardware support is included below.


This section highlights the required software packages for a successful build and installation of Scout. At this point in time we only develop under Linux and Mac OS X and therefore can not provide support for building on Windows-based systems.

The capabilities of the Scout Language rely heavily on the LLVM compiler infrastructure; including Clang, LLDB and the compiler-rt low-level runtime. As we modify each of these components they are included within our release. Please make sure to read the individual license agreements for each of these packages.

Operating System Support

Linux Systems: As mentioned above, our primary development environments are Mac OS X 10.9.X and several varieties of Linux-based distributions. A list of Linux releases that we monitor as part of our continuous integration development process are listed below:

Each of these platforms requires the installation of additional software development packages and libraries. This can be achieved used either the various software package management systems on these platforms or by downloading and building them directly from source. Further details on each required (and optional) package are provided below.

Mac OS X Systems: For Mac OS X systems we primarily test using 10.9.X and 10.10.X and the latest version of Apple's Xcode (currently 6.1). While there are several package distribution management systems for Mac OS X (e.g. macports) we typically avoid them and instead favor building and installing from source. If you use of these systems you may experience differences and/or conflicts with the details that follow.

Required Software Packages

The following software packages are required to produce a minimal version of Scout that targets CPU (x86) architectures (both single and multi-core):

  • CMake -- version 2.8.12 or later.

  • Qt -- version 5.4

  • OpenGL 3.X or higher -- We strongly recommend having access to a system with a GPU capable of supporting hardware accelerated OpenGL. We are currently exploring the use of software-based OpenGL support but can not recommend that as a viable option at this point in time. NOTE that we have primarily worked with NVIDIA GPUs for OpenGL support and are actively hardening support for AMD GPUs as well as beginning the initial exploration of both Intel's and ARM's GPU architectures.

Optional Software Packages

These additional packages expand Scout's target architectures and can be used to generate code for a mixed set of platforms from a single source file. For details on the various architectures supported by Scout see the Hardware section below.

  • NVIDA's CUDA -- we support CUDA version 6.X and Fermi- and Kepler-class cards (sorry, we haven't verified older GPU models are well supported).

  • OpenCL -- on platforms with AMD GPUs we support OpenCL-based code generation. NOTE: If our build configuration finds CUDA installed on your system OpenCL support will be disabled.

Our build configuration process will attempt to discover if you have any of these GPU development environments installed and will add support for them automatically. If you are using a non-standard install location for these packages you can set the following environment variables prior to invoking the build (more details below):

  • CUDA_DIR=/path/to/cuda/install

Building From Source

In the top-level directory of the source code there is a Makefile that will automate the process of creating an out-of-source build directory and running CMake. After the configuration step is completed, this approach will begin the compilation of the full distribution.

This process is as simple as invoking

$ make

from the root of the distribution.

To allow finer control of the build configuration the following environment variables may be set prior to invoking make.

  • SC_BUILD_NTHREADS -- Controls the use of a parallel build of the source. Set this variable to the number of make processes/threads to be executed. This is extremely useful in speeding up the build process. It not only helps to have a system with several process cores but also a lot of installed RAM -- a systems with several cores and limited memory can struggle through a parallel build.

    $ export SC_BUILD_NTHREADS=8      (compile with 8 build threads) 
  • SC_BUILD_TYPE -- Control whether a debug or release (optimized) build is used:

    $ export SC_BUILD_TYPE=DEBUG|RELEASE       (defaults to DEBUG)
  • SC_BUILD_DIR -- Controls both the name and location of the build directory:

    $ export SC_BUILD_DIR=/the/path/to/the/build
  • SC_BUILD_CMAKE_FLAGS -- (Advanced) This should primarily be used by those who have a detailed
    understanding of CMake and the configuration parameters within both Scout and LLVM. The set of provided flags will be passed to CMake as part of the configuration run. Full details of this using this option are currently beyond the scope of this document.


The Scout language and its supporting research activties are funded by the United States Departement of Energy, Office of Science, [Office of Advanced Scientific Computing Research]( .gov/ascr/) and overseen by Dr. Lucy Nowell.

You can’t perform that action at this time.