h1. Welcome to [Kotlin] documentation page\!

*Disclaimer*: this is not a language specification. Neither is it a complete reference manual. These documents are written to give you an impression of what kind of language [Kotlin] is. Some of the examples are somewhat speculative as the implementation of the compiler and library is currently in progress. Most of the details presented here are subject to change. *Your feedback and suggestions are very welcome.* You can write comments or file an issue in the [issue tracker|http://youtrack.jetbrains.net/issues/KT].

h3. Introductory Video

For an introduction, check out the presentation [*slides* and *video* from StrangeLoop 2011|http://www.infoq.com/presentations/The-Kotlin-Programming-Language].
More presentations are available on the [Talks and Publications] page.

h3. What is [Kotlin]?

"Project [Kotlin]" is the codename for a *statically-typed JVM-targeted programming language* developed by [*JetBrains*|http://jetbrains.com] and intended *for industrial use*.

h3. Why a new language?

At [JetBrains|http://jetbrains.com], we’ve been developing for the *Java* platform for a long time, and we know how good it is. On the other hand, we know that the *Java* programming language has certain limitations and problems that are either impossible or very hard to fix due to backward-compatibility issues. We know that *Java* is going to stand long, but we believe that the community can benefit from a new statically typed JVM-targeted language free of the legacy trouble and having the features so desperately wanted by the developers.

{anchor:Design goals}
The main *design goals* behind this project are
* to create a [*Java-compatible* language|Java interoperability],
* that *compiles* at least *as fast as Java*,
* make it *safer* than Java, i.e. statically check for common pitfalls such as [null pointer dereference|Null-safety],
* make it *more concise* than *Java* by supporting [variable type inference|Basic syntax walk-through#Define a local variable], [higher-order functions|Functions#Higher-order functions] (closures), [extension functions|Extension functions], [code in interfaces and first-class delegation|Classes and Inheritance], etc;
* and, keeping the useful level of expressiveness (see above), make it as *simple* as possible.

See more [here|http://blog.jetbrains.com/kotlin/2011/08/02/why-jetbrains-needs-kotlin/].

h3. What does it look like?

{jet}
fun main(args : Array<String>) {
  println("Hello, world!")
}
{jet}
See more [here|Hello, world!] and below.

h3. Development status

The compiler is being developed alongside with an [IntelliJ IDEA|http://www.jetbrains.com/idea/] integration.
[Kotlin] is an [Open Source project|http://github.com/jetbrains/kotlin]. Distributed under Apache 2 License.

{note:title=Kotlin is Under Development}Please report bugs to our [Issue Tracker|http://youtrack.jetbrains.com/issues/KT]{note}

If you're interested in keeping track of the project status, you're welcome to subscribe to the [Kotlin blog|http://blog.jetbrains.com/kotlin] or to [follow us on Twitter|http://twitter.com/project_kotlin].

h3. Read more

*FAQ*. See [this page|FAQ] for the answers to the most common questions.

API Documentation for the *Standard Library* can be found [here|http://jetbrains.github.com/kotlin/apidoc/stdlib/].
API Documentation for the *Runtime* can be found [here|http://jetbrains.github.com/kotlin/versions/snapshot/apidocs/].

Check out some *[Examples]* to get an idea of what [Kotlin] is:
* [Hello, world!]
* [Basic syntax walk-through|Basic syntax walk-through]
* [Address book] --- collections and higher-order functions
* [HTML builder|Type-safe Groovy-style builders] --- declarative structures
* [More...|Examples] --- extensions, pattern matching, IO, operator overloading, etc.

If you are a *Java* developer, look here:
* [Comparison to Java], and
* [Java interoperability]

If you got interested, take the *Feature tour*:
* [Modules and Compilation]
* [Packages]
* [Functions]
** [Operator overloading]
** [Extension functions]
** [Function literals]
** [Type-safe Groovy-style builders|Type-safe Groovy-style builders]
* [Properties And Fields]
* [Basic types]
** [Strings]
* [Expressions]
{children:page=Expressions|depth=5}
* [Pattern matching]
* [Classes and Inheritance]
{children:page=Classes and inheritance|depth=5}
* [Generics]
** [Runtime Type Information]
* [Null-safety|Null-safety]
* [Exceptions]
* [Java interoperability]

Check out the *[Grammar]* for a formal syntax description.