Features

Script language

Familiar syntax - The script syntax is similar to that of C or C++, with only a few differences.
Statically typed - Unlike most scripting languages that are dynamically typed this one uses the same static types as C++, and applications can register additional types.
Object oriented - The script language allows for declaration of classes and polymorphism through interfaces, and will soon permit inheritance as well.
Object handles - Pointers are not safe in a scripted environment, so AngelScript uses object handles instead. Object handles are almost like smart pointers, that control the life time of the object they hold.
Sandboxing - The library provides a secure environment for the scripts, i.e. the scripts can only access what the application explicitly exposes, and any built-in script objects are completely secure.

Run-time compiled - The library compiles the scripts into byte code and executes the byte code through a virtual machine.
Step by step execution - The scripts may be executed line by line, for controlled execution and debugging.
Detailed exceptions - When an exception occurs information about why and where can easily be obtained.
Line interpretation - The engine can interpret separate script lines using the currently compiled script. Useful for Quake like consoles.
Saving/loading byte code - The compiled bytecode can be saved and reloaded at a later time.
Modular - Scripts can be compiled into modules that can be dynamically linked with each other.
Concurrent scripts - Several scripts can be executed in parallel, by suspending and resuming them one by one. This allows for easy implementation of multi-tasking schemes, or even co-routines.
Debugging support - The application can examine the call stack and the value of local variables while running the scripts. The line callback feature allows the application to use breakpoints, do profiling, etc.

Direct access - The script engine can directly access and use registered functions, objects, and object members without the need to write proxy functions (where native calling conventions are supported).
C and C++ interface - There is a flat C interface that can be used by languages that don't interact well with C++ interfaces. It is successfully being used in Delphi projects.
Multithreading - The library can be used in a multithreaded environment.
Memory management - Objects are reference counted for easy management of objects that pass between script and application. An iterative garbage collector is used where circular references can occur. The application can also completely control the library's memory usage.

Cross platform - It has been confirmed to work on Win32, Linux, MacOS X, XBox, XBox 360, PS2, PSP, PS3, Dreamcast, Nintendo DS, and Windows Mobile.
CPU independent - Both 32bit and 64bit platforms are supported. Both big endian and little endian CPUs are supported. Confirmed CPUs: x86, amd64, sh4, mips, ppc, ppc64, arm.
Compiler support - It works with MSVC++, GNUC, MinGW, and DJGPP. Other compilers haven't been tested yet.
Native calling conventions - The library support native functions, i.e. without the need for wrappers on the following configurations, and other compatible ones:
- Win32 - MSVC - x86
- Win32 - MinGW - x86
- Linux - GNUC - x86
- MacOS X - GNUC - x86
- MacOS X - GNUC - ppc
- FreeBSD - GNUC - x86
- Dreamcast - GNUC - sh4
- PSP - GNUC - mips
- PS2 - GNUC - mips
- PS3 - GNUC - ppc/64
- XBox - MSVC - x86
- XBox 360 - MSVC - ppc/64
Maximum portability mode - When the library is compiled in this mode it should work on just about any compiler/platform that can compile standard compliant C++ code. Some features like native calling conventions are not available in this mode.
Cross language - With the flat C interface, other languages, such as Delphi, are also able to use the library.

No costs - The scripting library is completely free for all use, though donations are appreciated.
Well documented - Both the script language and library is documented.