diff --git a/README.md b/README.md
new file mode 100644
--- /dev/null
+++ b/README.md
@@ -0,0 +1,37 @@
+[![Build Status](https://travis-ci.org/Copilot-Language/copilot-language.svg?branch=master)](https://travis-ci.org/Copilot-Language/copilot-core)
+
+# Copilot: a stream DSL
+Copilot-language contains the actual embedded domain specific language that
+Copilot provides to its users. It comes with a series of basic operators and
+functionality, typically enough for most applications. Extended functionality
+is provided by the
+[copilot-libraries](https://github.com/Copilot-Language/copilot-libraries)
+module.
+
+Copilot is a runtime verification framework written in Haskell. It allows the
+user to write programs in a simple but powerful way using a stream-based
+approach.
+
+Programs can be interpreted for testing, or translated C99 code to be
+incorporated in a project, or as a standalone application. The C99 backend
+ensures us that the output is constant in memory and time, making it suitable
+for systems with hard realtime requirements.
+
+
+## Installation
+Copilot-language can be found on
+[Hackage](https://hackage.haskell.org/package/copilot-language). It is typically
+only installed as part of the complete Copilot distribution. For installation
+instructions, please refer to the [Copilot
+website](https://copilot-language.github.io).
+
+
+## Further information
+For further information, install instructions and documentation, please visit
+the Copilot website:
+[https://copilot-language.github.io](https://copilot-language.github.io)
+
+
+## License
+Copilot is distributed under the BSD-3-Clause license, which can be found
+[here](https://raw.githubusercontent.com/Copilot-Language/copilot-language/master/LICENSE).
diff --git a/copilot-language.cabal b/copilot-language.cabal
--- a/copilot-language.cabal
+++ b/copilot-language.cabal
@@ -1,6 +1,6 @@
 cabal-version:       >=1.10
 name:                copilot-language
-version:             2.2.1
+version:             3.0
 synopsis:            A Haskell-embedded DSL for monitoring hard real-time
                      distributed systems.
 description:
@@ -10,35 +10,39 @@
   Haskell that compiles into embedded C.  Copilot contains an interpreter,
   multiple back-end compilers, and other verification tools.  A tutorial, bug
   reports, and todos are available at
-  <https://github.com/leepike/copilot-discussion>.
+  <https://github.com/Copilot-Language/copilot-discussion>.
   .
   Examples are available at
-  <https://github.com/leepike/Copilot/tree/master/Examples>.
+  <https://github.com/Copilot-Language/Copilot/tree/master/Examples>.
 
 license:             BSD3
 license-file:        LICENSE
-author:              Lee Pike, Robin Morisset, Alwyn Goodloe, Sebastian Niller,
-                     Nis Nordby Wegmann
-maintainer:          leepike@gmail.com
+author:              Frank Dedden, Lee Pike, Robin Morisset, Alwyn Goodloe,
+                     Sebastian Niller, Nis Nordby Wegmann
+maintainer:          Frank Dedden <dev@dedden.net>
 stability:           Experimental
 category:            Language, Embedded
 build-type:          Simple
+extra-source-files:  README.md
 
 source-repository head
     type:       git
-    location:   git://github.com/leepike/copilot-language.git
+    location:   https://github.com/Copilot-Language/copilot-language.git
 
 library
   default-language: Haskell2010
   hs-source-dirs: src
-  build-depends: array
-               , base >= 4.0 && < 5
-               , containers >= 0.4
-               , data-reify >= 0.6
-               , mtl >= 2.0 && < 3
-               , ghc-prim >= 0.2
-               , copilot-core >= 2.2.1
-               , copilot-theorem >= 2.1
+  build-depends: base            >= 4.9 && < 5
+
+               , array           >= 0.5 && < 0.6
+               , containers      >= 0.4 && < 0.7
+               , data-reify      >= 0.6 && < 0.7
+               , mtl             >= 2.0 && < 3
+               , ghc-prim        >= 0.3 && < 0.6
+
+               , copilot-core    >= 3.0 && < 3.1
+               , copilot-theorem >= 3.0 && < 3.1
+
   exposed-modules: Copilot
                  , Copilot.Language
                  , Copilot.Language.Operators.BitWise
@@ -54,25 +58,17 @@
                  , Copilot.Language.Operators.Mux
                  , Copilot.Language.Operators.Ord
                  , Copilot.Language.Operators.Temporal
+                 , Copilot.Language.Operators.Array
+                 , Copilot.Language.Operators.Struct
                  , Copilot.Language.Prelude
                  , Copilot.Language.Reify
-  other-modules:   Copilot.Language.Analyze
-                 , Copilot.Language.Interpret
                  , Copilot.Language.Stream
                  , Copilot.Language.Spec
+  other-modules:   Copilot.Language.Analyze
+                 , Copilot.Language.Interpret
                  , System.Mem.StableName.Dynamic
                  , System.Mem.StableName.Map
                  , Copilot.Language.Error
   ghc-options:
     -fwarn-tabs
-    -auto-all
-    -caf-all
     -Wall
-
-    -fpackage-trust
-    -trust=array
-    -trust=base
-    -trust=containers
-    -trust=copilot-core
-
-
diff --git a/src/Copilot/Language.hs b/src/Copilot/Language.hs
--- a/src/Copilot/Language.hs
+++ b/src/Copilot/Language.hs
@@ -10,6 +10,8 @@
   ( module Data.Int
   , module Data.Word
   , module Copilot.Core
+  , module Copilot.Core.Type
+  , module Copilot.Core.Type.Array
   , module Copilot.Language.Error
   , module Copilot.Language.Interpret
   , module Copilot.Language.Operators.Boolean
@@ -24,6 +26,8 @@
   , module Copilot.Language.Operators.Ord
   , module Copilot.Language.Operators.Temporal
   , module Copilot.Language.Operators.BitWise
+  , module Copilot.Language.Operators.Array
+  , module Copilot.Language.Operators.Struct
   , module Copilot.Language.Prelude
   , Spec
   , Stream
@@ -39,6 +43,8 @@
 import Data.Int hiding (Int)
 import Data.Word
 import Copilot.Core (Name, Typed)
+import Copilot.Core.Type
+import Copilot.Core.Type.Array
 import qualified Copilot.Core.PrettyPrint as PP
 import Copilot.Language.Error
 import Copilot.Language.Interpret
@@ -54,6 +60,8 @@
 import Copilot.Language.Operators.Ord
 import Copilot.Language.Operators.Temporal
 import Copilot.Language.Operators.BitWise
+import Copilot.Language.Operators.Array
+import Copilot.Language.Operators.Struct
 import Copilot.Language.Reify
 import Copilot.Language.Prelude
 import Copilot.Language.Spec
diff --git a/src/Copilot/Language/Analyze.hs b/src/Copilot/Language/Analyze.hs
--- a/src/Copilot/Language/Analyze.hs
+++ b/src/Copilot/Language/Analyze.hs
@@ -147,19 +147,6 @@
                       SeenFun  -> throw NestedExternFun
                       SeenArr  -> throw NestedArray
                       SeenStruct-> throw InvalidField
-      ExternArray _ idx _ _ -> case seenExt of
-                                 NoExtern  -> go SeenArr nodes' idx
-                                 SeenFun   -> throw NestedExternFun
-                                 SeenArr   -> throw NestedArray
-                                 SeenStruct-> go SeenStruct nodes' idx
-      ExternStruct _ sargs -> case seenExt of
-                                NoExtern  ->
-                                  mapM_ (\(_, Arg a) -> go SeenStruct nodes' a) sargs
-                                SeenFun   -> throw NestedExternFun
-                                SeenArr   -> throw NestedArray
-                                SeenStruct->
-                                  mapM_ (\(_, Arg a) -> go SeenStruct nodes' a) sargs
-      GetField e _        -> analyzeAppend refStreams dstn e () analyzeExpr --Copied from `Append` case
       Local e f           -> go seenExt nodes' e >>
                              go seenExt nodes' (f (Var "dummy"))
       Var _               -> return ()
@@ -359,22 +346,6 @@
                      , externFunArgs = (name, argTypes) : externFunArgs env''
                      }
 
-      ExternArray name idx _ _ -> do
-        env' <- go nodes env idx
-        let arr = ( name, getSimpleType stream )
-        return env' { externArrEnv = arr : externArrEnv env' }
-
-      ExternStruct name sargs -> do
-        env' <- foldM (\env' (_, Arg arg_) -> go nodes env' arg_)
-                  env sargs
-        --let argTypes = map (\(Arg arg_) -> (n, getSimpleType arg_)) sargs
-        let argTypes = map (\(_, Arg arg_) -> getSimpleType arg_) sargs
-        let struct = (name, getSimpleType stream)
-        return env' { externStructEnv = struct : externStructEnv env'
-                    , externStructArgs = (name, argTypes) : externStructArgs env' }
-
-      GetField _ _           -> return env
-
       Local e _              -> go nodes env e
       Var _                  -> return env
       Op1 _ e                -> go nodes env e
@@ -386,16 +357,7 @@
       Label _ e              -> go nodes env e
 
 --------------------------------------------------------------------------------
-{-
-getArgName :: forall a. C.Typed a => Stream a -> String
-getArgName arg_stream =
-  case arg_stream of
-    Extern cs _          -> cs
-    ExternFun cs _ _     -> cs
-    ExternArray cs _ _ _ -> cs
-    ExternStruct cs _    -> cs
-    _                    -> ""
--}
+
 getSimpleType :: forall a. C.Typed a => Stream a -> C.SimpleType
 getSimpleType _ = C.simpleType (C.typeOf :: C.Type a)
 
diff --git a/src/Copilot/Language/Operators/Array.hs b/src/Copilot/Language/Operators/Array.hs
new file mode 100644
--- /dev/null
+++ b/src/Copilot/Language/Operators/Array.hs
@@ -0,0 +1,30 @@
+{-# LANGUAGE Safe #-}
+
+{-# LANGUAGE TypeFamilies #-}
+
+module Copilot.Language.Operators.Array
+  ( (.!!)
+  ) where
+
+import Copilot.Core             ( Typed
+                                , Op2 (Index)
+                                , typeOf
+                                , Array
+                                , InnerType
+                                , Flatten)
+import Copilot.Language.Stream  (Stream (..))
+
+import Data.Word                (Word32)
+import GHC.TypeLits             (KnownNat)
+
+--------------------------------------------------------------------------------
+
+(.!!) :: ( KnownNat n
+         , t' ~ InnerType t
+         , Flatten t t'
+         , Typed t
+         , Typed t'
+         ) => Stream (Array n t) -> Stream Word32 -> Stream t
+arr .!! n = Op2 (Index typeOf) arr n
+
+--------------------------------------------------------------------------------
diff --git a/src/Copilot/Language/Operators/Cast.hs b/src/Copilot/Language/Operators/Cast.hs
--- a/src/Copilot/Language/Operators/Cast.hs
+++ b/src/Copilot/Language/Operators/Cast.hs
@@ -8,7 +8,7 @@
 {-# LANGUAGE MultiParamTypeClasses #-}
 
 module Copilot.Language.Operators.Cast
-  ( cast, unsafeCast ) where
+  ( cast, unsafeCast, Cast, UnsafeCast ) where
 
 import qualified Copilot.Core.Operators as C
 import Copilot.Core.Type
diff --git a/src/Copilot/Language/Operators/Extern.hs b/src/Copilot/Language/Operators/Extern.hs
--- a/src/Copilot/Language/Operators/Extern.hs
+++ b/src/Copilot/Language/Operators/Extern.hs
@@ -20,19 +20,6 @@
   , externF
   , externD
   , externFun
-  , externArray
-  , externArrayB
-  , externArrayW8
-  , externArrayW16
-  , externArrayW32
-  , externArrayW64
-  , externArrayI8
-  , externArrayI16
-  , externArrayI32
-  , externArrayI64
-  , externArrayF
-  , externArrayD
-  , externStruct
   , funArg -- * Deprecated.
   ) where
 
@@ -51,28 +38,10 @@
 externFun :: Typed a => String -> [Arg] -> Maybe (Stream a) -> Stream a
 externFun = ExternFun
 
-externArray :: (Typed a, Typed b, Integral a)
-            => String -> Stream a -> Size -> Maybe [[b]] -> Stream b
-externArray = ExternArray
-
 -- | Deprecated.
 funArg :: Typed a => Stream a -> Arg
 funArg = Arg
 
-externStruct :: Typed a => String -> [(String, Arg)] -> Stream a
-externStruct = ExternStruct
-
-{-(#) :: Typed a => Core.StructData -> String -> Stream a
-(Core.StructData {Core.structName = x, Core.structInst = y})#z = getField x z
-  where
-    getField struct_nm field_nm =
-      let test = find (\(Core.StructData name _) -> name == struct_nm) structs in
-      case test of
-        Nothing -> error "No struct named \"" ++ struct_nm ++ "\" in the spec"
-        Just element ->
-          fromMaybe (find (\(Core.SExpr name _) -> name == field_nm) (element Core.structInst))
-            (error "No field by the name of \"" ++ field_nm ++ "\"") element
--}
 --------------------------------------------------------------------------------
 
 externB   :: String -> Maybe [Bool] -> Stream Bool
@@ -97,50 +66,3 @@
 externF   = extern
 externD   :: String -> Maybe [Double] -> Stream Double
 externD   = extern
-
---------------------------------------------------------------------------------
-
-externArrayB   :: (Typed a, Integral a)
-               => String -> Stream a -> Size
-                         -> Maybe [[Bool]] -> Stream Bool
-externArrayB   = externArray
-externArrayW8  :: (Typed a, Integral a)
-               => String -> Stream a -> Size
-                         -> Maybe [[Word8]] -> Stream Word8
-externArrayW8  = externArray
-externArrayW16 :: (Typed a, Integral a)
-               => String -> Stream a -> Size
-                         -> Maybe [[Word16]] -> Stream Word16
-externArrayW16 = externArray
-externArrayW32 :: (Typed a, Integral a)
-               => String -> Stream a -> Size
-                         -> Maybe [[Word32]] -> Stream Word32
-externArrayW32 = externArray
-externArrayW64 :: (Typed a, Integral a)
-               => String -> Stream a -> Size
-                         -> Maybe [[Word64]] -> Stream Word64
-externArrayW64 = externArray
-externArrayI8  :: (Typed a, Integral a)
-               => String -> Stream a -> Size
-                         -> Maybe [[Int8]] -> Stream Int8
-externArrayI8  = externArray
-externArrayI16 :: (Typed a, Integral a)
-               => String -> Stream a -> Size
-                         -> Maybe [[Int16]] -> Stream Int16
-externArrayI16 = externArray
-externArrayI32 :: (Typed a, Integral a)
-               => String -> Stream a -> Size
-                         -> Maybe [[Int32]] -> Stream Int32
-externArrayI32 = externArray
-externArrayI64 :: (Typed a, Integral a)
-               => String -> Stream a -> Size
-                         -> Maybe [[Int64]] -> Stream Int64
-externArrayI64 = externArray
-externArrayF   :: (Typed a, Integral a)
-               => String -> Stream a -> Size
-                         -> Maybe [[Float]] -> Stream Float
-externArrayF   = externArray
-externArrayD   :: (Typed a, Integral a)
-               => String -> Stream a -> Size
-                         -> Maybe [[Double]] -> Stream Double
-externArrayD   = externArray
diff --git a/src/Copilot/Language/Operators/Struct.hs b/src/Copilot/Language/Operators/Struct.hs
new file mode 100644
--- /dev/null
+++ b/src/Copilot/Language/Operators/Struct.hs
@@ -0,0 +1,19 @@
+{-# LANGUAGE Safe #-}
+
+module Copilot.Language.Operators.Struct
+  ( (#)
+  ) where
+
+import Copilot.Core.Type
+import Copilot.Core.Operators
+import Copilot.Language.Stream  (Stream (..))
+
+import GHC.TypeLits             (KnownSymbol)
+
+--------------------------------------------------------------------------------
+
+(#) :: (KnownSymbol s, Typed t, Typed a, Struct a)
+      => Stream a -> (a -> Field s t) -> Stream t
+(#) s f = Op1 (GetField typeOf typeOf (accessorname f)) s
+
+--------------------------------------------------------------------------------
diff --git a/src/Copilot/Language/Operators/Temporal.hs b/src/Copilot/Language/Operators/Temporal.hs
--- a/src/Copilot/Language/Operators/Temporal.hs
+++ b/src/Copilot/Language/Operators/Temporal.hs
@@ -9,7 +9,6 @@
 module Copilot.Language.Operators.Temporal
   ( (++)
   , drop
-  , (#)
   ) where
 
 import Copilot.Core (Typed)
@@ -29,11 +28,3 @@
 drop _ ( Const j )   = Const j
 drop i ( Drop  j s ) = Drop (fromIntegral i + j) s
 drop i s             = Drop (fromIntegral i)     s
-
-(#) :: (Typed a, Typed b) => Stream a -> String -> Stream b
-(#) = GetField
-{-(ExternStruct cs sargs) # (Extern nm i) 		 				= Extern nm i
-(ExternStruct cs sargs) # (ExternFun nm args i) 		= ExternFun nm args i
-(ExternStruct cs sargs) # (ExternArray nm strm j i)	= ExternArray nm strm j i
-(ExternStruct cs sargs) # (ExternStruct nm args)	  = ExternStruct nm args-}
---(ExternStruct cs sargs) # name = GetField (ExternStruct cs sargs) name
diff --git a/src/Copilot/Language/Reify.hs b/src/Copilot/Language/Reify.hs
--- a/src/Copilot/Language/Reify.hs
+++ b/src/Copilot/Language/Reify.hs
@@ -208,27 +208,6 @@
 
     ------------------------------------------------------
 
-    ExternArray cs e size mXs -> do
-      w <- go e
-      return $ Core.ExternArray typeOf typeOf cs size w mXs Nothing
-
-    ------------------------------------------------------
-
-    ExternStruct cs sargs -> do
-      args' <- mapM (\(name, Arg e) -> mkStrArg (name, Arg e)) sargs
-      return $ Core.ExternStruct typeOf cs args' Nothing
-
-    ------------------------------------------------------
-
-    GetField struct field -> do
-      s <- go struct
-      return $ Core.GetField typeOf typeOf s field
-      {-  ISSUE: UNLIKE APPEND, GETFIELD DOES NOT HAVE CONSISTENT RETURN TYPE
-            --> NEED TO PROPERLY DEFINE GETFIELD IN EXPR
-              --> IMPLEMENT GETFIELD FROM CORE THROUGH LANGUAGE -}
-
-    ------------------------------------------------------
-
     Op1 op e -> do
       w <- go e
       return $ Core.Op1 op w
diff --git a/src/Copilot/Language/Stream.hs b/src/Copilot/Language/Stream.hs
--- a/src/Copilot/Language/Stream.hs
+++ b/src/Copilot/Language/Stream.hs
@@ -33,12 +33,6 @@
               => String -> Maybe [a] -> Stream a
   ExternFun   :: Typed a
               => String -> [Arg] -> Maybe (Stream a) -> Stream a
-  ExternArray :: (Typed a, Typed b, Integral a)
-              => String -> Stream a -> Int -> Maybe [[b]] -> Stream b
-  ExternStruct:: Typed a
-              => String -> [(String, Arg)] -> Stream a
-  GetField    :: (Typed a, Typed b)
-              => Stream a -> String -> Stream b
   Local       :: (Typed a, Typed b)
               => Stream a -> (Stream a -> Stream b) -> Stream b
   Var         :: Typed a