diff --git a/grin/src/AbstractInterpretation/CreatedBy/CodeGenBase.hs b/grin/src/AbstractInterpretation/CreatedBy/CodeGenBase.hs
index 05c9e28d..0eadaf28 100644
--- a/grin/src/AbstractInterpretation/CreatedBy/CodeGenBase.hs
+++ b/grin/src/AbstractInterpretation/CreatedBy/CodeGenBase.hs
@@ -126,8 +126,8 @@ codeGenBlock_ = fmap snd . codeGenBlock
 codeGenSimpleType :: SimpleType -> CG IR.Reg
 codeGenSimpleType = \case
   T_Unit                -> newRegWithSimpleType (-1)
-  T_Int64               -> newRegWithSimpleType (-2)
-  T_Word64              -> newRegWithSimpleType (-3)
+--  T_Int width           -> newRegWithSimpleType (-2)
+--  T_Word width          -> newRegWithSimpleType (-3)
   T_Float               -> newRegWithSimpleType (-4)
   T_Bool                -> newRegWithSimpleType (-5)
   T_String              -> newRegWithSimpleType (-6)
diff --git a/grin/src/AbstractInterpretation/HeapPointsTo/CodeGen.hs b/grin/src/AbstractInterpretation/HeapPointsTo/CodeGen.hs
index f5214f96..ecbf43c4 100644
--- a/grin/src/AbstractInterpretation/HeapPointsTo/CodeGen.hs
+++ b/grin/src/AbstractInterpretation/HeapPointsTo/CodeGen.hs
@@ -52,8 +52,8 @@ class (Typeable a, Enum a, Bounded a) => IntValue a where
 codegenSimpleType :: SimpleType -> IR.SimpleType
 codegenSimpleType = \case
   T_Unit    -> -1
-  T_Int64   -> -2
-  T_Word64  -> -3
+--  T_Int w   -> -2
+--  T_Word w  -> -3
   T_Float   -> -4
   T_Bool    -> -5
   T_String  -> -6
diff --git a/grin/src/AbstractInterpretation/HeapPointsTo/CodeGenBase.hs b/grin/src/AbstractInterpretation/HeapPointsTo/CodeGenBase.hs
index 90b9adc0..7abaffec 100644
--- a/grin/src/AbstractInterpretation/HeapPointsTo/CodeGenBase.hs
+++ b/grin/src/AbstractInterpretation/HeapPointsTo/CodeGenBase.hs
@@ -128,8 +128,8 @@ codeGenBlock_ = fmap snd . codeGenBlock
 codeGenSimpleType :: SimpleType -> CG IR.Reg
 codeGenSimpleType = \case
   T_Unit                -> newRegWithSimpleType (-1)
-  T_Int64               -> newRegWithSimpleType (-2)
-  T_Word64              -> newRegWithSimpleType (-3)
+--  T_Int width           -> newRegWithSimpleType (-2)
+--  T_Word width          -> newRegWithSimpleType (-3)
   T_Float               -> newRegWithSimpleType (-4)
   T_Bool                -> newRegWithSimpleType (-5)
   T_String              -> newRegWithSimpleType (-6)
diff --git a/grin/src/AbstractInterpretation/HeapPointsTo/Result.hs b/grin/src/AbstractInterpretation/HeapPointsTo/Result.hs
index 64097e29..318c289b 100644
--- a/grin/src/AbstractInterpretation/HeapPointsTo/Result.hs
+++ b/grin/src/AbstractInterpretation/HeapPointsTo/Result.hs
@@ -24,8 +24,8 @@ import AbstractInterpretation.HeapPointsTo.CodeGenBase (HPTMapping)
 type Loc = Int
 
 data SimpleType
-  = T_Int64
-  | T_Word64
+  = T_Int Word32
+  | T_Word Word32
   | T_Float
   | T_Bool
   | T_Unit
@@ -99,8 +99,8 @@ concat <$> mapM makeLenses [''NodeSet, ''TypeSet, ''HPTResult]
 toSimpleType :: IR.SimpleType -> SimpleType
 toSimpleType = \case
   -1 -> T_Unit
-  -2 -> T_Int64
-  -3 -> T_Word64
+--  -2 -> T_Int w
+--  -3 -> T_Word w
   -4 -> T_Float
   -5 -> T_Bool
   -6 -> T_String
diff --git a/grin/src/AbstractInterpretation/LiveVariable/CodeGenBase.hs b/grin/src/AbstractInterpretation/LiveVariable/CodeGenBase.hs
index 433ca7db..33d14de2 100644
--- a/grin/src/AbstractInterpretation/LiveVariable/CodeGenBase.hs
+++ b/grin/src/AbstractInterpretation/LiveVariable/CodeGenBase.hs
@@ -124,8 +124,8 @@ codeGenBlock_ = fmap snd . codeGenBlock
 codeGenSimpleType :: SimpleType -> CG IR.Reg
 codeGenSimpleType = \case
   T_Unit                -> newRegWithSimpleType (-1)
-  T_Int64               -> newRegWithSimpleType (-2)
-  T_Word64              -> newRegWithSimpleType (-3)
+--  T_Int w               -> newRegWithSimpleType (-2)
+--  T_Word w              -> newRegWithSimpleType (-3)
   T_Float               -> newRegWithSimpleType (-4)
   T_Bool                -> newRegWithSimpleType (-5)
   T_String              -> newRegWithSimpleType (-6)
diff --git a/grin/src/AbstractInterpretation/Model.hs b/grin/src/AbstractInterpretation/Model.hs
index e3f2bd51..53a32913 100644
--- a/grin/src/AbstractInterpretation/Model.hs
+++ b/grin/src/AbstractInterpretation/Model.hs
@@ -523,8 +523,8 @@ instance ToTypeSet Val where typeSet = litOrConstTagNodeToTypeSet
 
 typeOfLiteral :: Lit -> SimpleType
 typeOfLiteral = \case
-  LInt64  _ -> T_Int64
-  LWord64 _ -> T_Word64
+  LInt w  _ -> T_Int w
+  LWord w _ -> T_Word w
   LFloat  _ -> T_Float
   LBool   _ -> T_Bool
 
@@ -591,9 +591,9 @@ primitive name = case name of
   "_prim_bool_ne"   -> op [bool, bool] bool
   _ -> Nothing
   where
-    int = T_Int64
+    int = T_Int 64
     bool = T_Bool
-    word = T_Word64
+    word = T_Word 64
     unit = T_Unit
     float = T_Float
 
diff --git a/grin/src/Grin/ExtendedSyntax/Parse/AST.hs b/grin/src/Grin/ExtendedSyntax/Parse/AST.hs
index 2516aa8b..52158b94 100644
--- a/grin/src/Grin/ExtendedSyntax/Parse/AST.hs
+++ b/grin/src/Grin/ExtendedSyntax/Parse/AST.hs
@@ -72,10 +72,16 @@ value = Lit <$> literal <|>
         try (Unit <$ op "()") <|>
         Undefined <$> parens (kw "#undefined" *> op "::" *> typeAnnot)
 
+wordLiteral :: Parser Lit
+wordLiteral = lexeme (LWord <$> (integer <* C.char 'u') <*> L.decimal)
+
+intLiteral :: Parser Lit
+intLiteral = lexeme (LInt <$> (signedInteger <* C.char 'i') <*> L.decimal)
+
 literal :: Parser Lit
 literal = (try $ LFloat . realToFrac <$> signedFloat) <|>
-          (try $ LWord64 . fromIntegral <$> lexeme (L.decimal <* C.char 'u')) <|>
-          (try $ LInt64 . fromIntegral <$> signedInteger) <|>
+          (try $ wordLiteral) <|>
+          (try $ intLiteral) <|>
           (try $ LBool <$> (True <$ kw "#True" <|> False <$ kw "#False")) <|>
           (try $ LString <$> lexeme (C.char '#' *> quotedString)) <|>
           (try $ LChar <$> lexeme (C.string "#'" *> (escaped <|> anySingle) <* C.char '\''))
diff --git a/grin/src/Grin/ExtendedSyntax/Syntax.hs b/grin/src/Grin/ExtendedSyntax/Syntax.hs
index 71090d67..7bb71b52 100644
--- a/grin/src/Grin/ExtendedSyntax/Syntax.hs
+++ b/grin/src/Grin/ExtendedSyntax/Syntax.hs
@@ -53,8 +53,8 @@ isExternalName es n = n `Prelude.elem` (eName <$> es)
 -- QUESTION: Now #undefined can be pattern matched on.
 -- Should the linter warn about this?
 data Lit
-  = LInt64  Int64
-  | LWord64 Word64
+  = LInt    Word32 Int
+  | LWord   Word32 Word
   | LFloat  Float
   | LBool   Bool
   | LString Text
diff --git a/grin/src/Grin/Parse/AST.hs b/grin/src/Grin/Parse/AST.hs
index bbd34f2c..b0423e52 100644
--- a/grin/src/Grin/Parse/AST.hs
+++ b/grin/src/Grin/Parse/AST.hs
@@ -89,10 +89,16 @@ value = Unit <$ op "()" <|>
         ValTag <$> tag <|>
         simpleValue
 
+wordLiteral :: Parser Lit
+wordLiteral = lexeme (LWord <$> (integer <* C.char 'u') <*> L.decimal)
+
+intLiteral :: Parser Lit
+intLiteral = lexeme (LInt <$> (signedInteger <* C.char 'i') <*> L.decimal)
+
 literal :: Parser Lit
 literal = (try $ LFloat . realToFrac <$> signedFloat) <|>
-          (try $ LWord64 . fromIntegral <$> lexeme (L.decimal <* C.char 'u')) <|>
-          (try $ LInt64 . fromIntegral <$> signedInteger) <|>
+          (try $ wordLiteral) <|>
+          (try $ intLiteral) <|>
           (try $ LBool <$> (True <$ kw "#True" <|> False <$ kw "#False")) <|>
           (try $ LString <$> lexeme (C.char '#' *> quotedString)) <|>
           (try $ LChar <$> lexeme (C.string "#'" *> (escaped <|> anySingle) <* C.char '\''))
diff --git a/grin/src/Grin/Parse/Basic.hs b/grin/src/Grin/Parse/Basic.hs
index 0efeb808..699d1e1d 100644
--- a/grin/src/Grin/Parse/Basic.hs
+++ b/grin/src/Grin/Parse/Basic.hs
@@ -32,7 +32,7 @@ keywords = Set.fromList
   ] `Set.union` simpleTypes
 
 simpleTypes = Set.fromList
-  [ "T_Int64", "T_Word64", "T_Float"
+  [ "T_Int", "T_Word", "T_Float"
   , "T_Bool",  "T_Unit"
   , "T_Location", "T_Dead"
   , "T_String", "T_Char"
@@ -140,8 +140,8 @@ tag = Tag C <$ char 'C' <*> var <|>
 
 simpleType :: Parser SimpleType
 simpleType =
-  T_Int64 <$ kw "T_Int64" <|>
-  T_Word64 <$ kw "T_Word64" <|>
+  T_Int <$ kw "T_Int" <*> integer <|>
+  T_Word <$ kw "T_Word" <*> integer <|>
   T_Float <$ kw "T_Float" <|>
   T_Bool <$ kw "T_Bool" <|>
   T_Unit <$ kw "T_Unit" <|>
diff --git a/grin/src/Grin/Pretty.hs b/grin/src/Grin/Pretty.hs
index bf1ce962..754c1ea8 100644
--- a/grin/src/Grin/Pretty.hs
+++ b/grin/src/Grin/Pretty.hs
@@ -135,12 +135,12 @@ instance Pretty Val where
 
 instance Pretty Lit where
   pretty = \case
-    LInt64 a   -> integer $ fromIntegral a
-    LWord64 a  -> integer (fromIntegral a) <> text "u"
-    LFloat a   -> float a
-    LBool a    -> text "#" <> text (show a)
-    LString a  -> text "#" <> text (show a)
-    LChar a    -> text "#" <> text (show a)
+    LInt w a  -> integer (fromIntegral a) <> text "i" <> integer (fromIntegral w)
+    LWord w a -> integer (fromIntegral a) <> text "u" <> integer (fromIntegral w)
+    LFloat a  -> float a
+    LBool a   -> text "#" <> text (show a)
+    LString a -> text "#" <> text (show a)
+    LChar a   -> text "#" <> text (show a)
 
 instance Pretty CPat where
   pretty = \case
diff --git a/grin/src/Grin/Research.hs b/grin/src/Grin/Research.hs
index b44d0c73..78b43859 100644
--- a/grin/src/Grin/Research.hs
+++ b/grin/src/Grin/Research.hs
@@ -148,8 +148,8 @@ calcSimpleTypesAlg = \case
 
   (_ CCTC.:< SReturnF v) ->
     case v of
-      (Lit (LInt64  _)) -> pure $ IInfo T_Int64
-      (Lit (LWord64 _)) -> pure $ IInfo T_Word64
+      (Lit (LInt w  _)) -> pure $ IInfo $ T_Int w
+      (Lit (LWord w _)) -> pure $ IInfo $ T_Word w
       (Lit (LFloat  _)) -> pure $ IInfo T_Float
       (Lit (LBool   _)) -> pure $ IInfo T_Bool
       (Lit (LString _)) -> pure $ IInfo T_String
diff --git a/grin/src/Grin/Syntax.hs b/grin/src/Grin/Syntax.hs
index 63049e90..f03abfb1 100644
--- a/grin/src/Grin/Syntax.hs
+++ b/grin/src/Grin/Syntax.hs
@@ -55,8 +55,8 @@ isExternalName es n = n `Prelude.elem` (eName <$> es)
 -- QUESTION: Now #undefined can be pattern matched on.
 -- Should the linter warn about this?
 data Lit
-  = LInt64  Int64
-  | LWord64 Word64
+  = LInt    Word32 Int
+  | LWord   Word32 Word
   | LFloat  Float
   | LBool   Bool
   | LString Text
diff --git a/grin/src/Grin/SyntaxDefs.hs b/grin/src/Grin/SyntaxDefs.hs
index 7d5ed880..0dc0266c 100644
--- a/grin/src/Grin/SyntaxDefs.hs
+++ b/grin/src/Grin/SyntaxDefs.hs
@@ -2,6 +2,7 @@
 module Grin.SyntaxDefs where
 
 import Data.Text (Text, unpack)
+import Data.Word
 import Control.DeepSeq
 import GHC.Generics (Generic)
 import Data.Data
@@ -52,8 +53,8 @@ data Tag = Tag
 type Loc = Int
 
 data SimpleType
-  = T_Int64
-  | T_Word64
+  = T_Int {_width :: Word32}
+  | T_Word {_width :: Word32}
   | T_Float
   | T_Bool
   | T_Unit
diff --git a/grin/src/Grin/TypeCheck.hs b/grin/src/Grin/TypeCheck.hs
index 562f0b13..4d6aa745 100644
--- a/grin/src/Grin/TypeCheck.hs
+++ b/grin/src/Grin/TypeCheck.hs
@@ -36,8 +36,8 @@ typeEnvFromHPTResult :: HPTResult -> Either String TypeEnv.TypeEnv
 typeEnvFromHPTResult hptResult = typeEnv where
   convertSimpleType :: SimpleType -> Either String TypeEnv.SimpleType
   convertSimpleType = \case
-    T_Int64               -> pure TypeEnv.T_Int64
-    T_Word64              -> pure TypeEnv.T_Word64
+    T_Int w               -> pure $ TypeEnv.T_Int w
+    T_Word w              -> pure $ TypeEnv.T_Word w
     T_Float               -> pure TypeEnv.T_Float
     T_Bool                -> pure TypeEnv.T_Bool
     T_Unit                -> pure TypeEnv.T_Unit
diff --git a/grin/src/Grin/TypeEnv.hs b/grin/src/Grin/TypeEnv.hs
index 1809e224..0000781a 100644
--- a/grin/src/Grin/TypeEnv.hs
+++ b/grin/src/Grin/TypeEnv.hs
@@ -10,6 +10,7 @@ import Data.Int
 import Data.Map (Map)
 import Data.Set (Set)
 import Data.Vector (Vector)
+import Data.Word
 import qualified Data.Map as Map
 import qualified Data.Set as Set
 import qualified Data.Vector as Vector
@@ -34,8 +35,8 @@ dead_t = T_SimpleType T_Dead
 unit_t :: Type
 unit_t = T_SimpleType T_Unit
 
-int64_t :: Type
-int64_t = T_SimpleType T_Int64
+int_t :: Word32 -> Type
+int_t = T_SimpleType . T_Int
 
 bool_t :: Type
 bool_t = T_SimpleType T_Bool
@@ -113,12 +114,12 @@ typeOfLit = T_SimpleType . typeOfLitST
 
 typeOfLitST :: Lit -> SimpleType
 typeOfLitST lit = case lit of
-  LInt64{}  -> T_Int64
-  LWord64{} -> T_Word64
-  LFloat{}  -> T_Float
-  LBool{}   -> T_Bool
-  LString{} -> T_String
-  LChar{}   -> T_Char
+  LInt width _  -> T_Int width
+  LWord width _ -> T_Word width
+  LFloat{}      -> T_Float
+  LBool{}       -> T_Bool
+  LString{}     -> T_String
+  LChar{}       -> T_Char
 
 -- Type of literal like values
 typeOfVal :: Val -> Type
diff --git a/grin/src/Reducer/LLVM/CodeGen.hs b/grin/src/Reducer/LLVM/CodeGen.hs
index 77fa6151..cdf8bd7e 100644
--- a/grin/src/Reducer/LLVM/CodeGen.hs
+++ b/grin/src/Reducer/LLVM/CodeGen.hs
@@ -66,8 +66,8 @@ toLLVM fname mod = withContext $ \ctx -> do
 
 codeGenLit :: Lit -> CG C.Constant
 codeGenLit = \case
-  LInt64 v  -> pure $ Int {integerBits=64, integerValue=fromIntegral v}
-  LWord64 v -> pure $ Int {integerBits=64, integerValue=fromIntegral v}
+  LInt w v  -> pure $ Int {integerBits=w, integerValue=fromIntegral v}
+  LWord w v -> pure $ Int {integerBits=w, integerValue=fromIntegral v}
   LFloat v  -> pure $ C.Float {floatValue=F.Single v}
   LBool v   -> pure $ Int {integerBits=1, integerValue=if v then 1 else 0}
   LChar v   -> pure $ Int {integerBits=8, integerValue=fromIntegral $ fromEnum v}
@@ -141,8 +141,8 @@ getCPatName :: CPat -> Grin.Name
 getCPatName = \case
   TagPat  tag   -> tagName tag
   LitPat  lit   -> case lit of
-    LInt64 v  -> "int_" <> showTS v
-    LWord64 v -> "word_" <> showTS v
+    LInt w v  -> "int" <> showTS w <> "_" <> showTS v
+    LWord w v -> "word" <> showTS w <> "_" <> showTS v
     LBool v   -> "bool_" <> showTS v
     LChar v   -> "char_" <> showTS v
     LString v -> error "pattern match on string is not supported"
@@ -587,7 +587,7 @@ runtimeErrorExternal =
   external
     (typeGenSimpleType T_Unit)
     (mkName "__runtime_error")
-    [(typeGenSimpleType T_Int64, mkName "x0")]
+    [(typeGenSimpleType (T_Int 64), mkName "x0")]
 
 errorBlock :: CG ()
 errorBlock = do
diff --git a/grin/src/Reducer/LLVM/PrimOps.hs b/grin/src/Reducer/LLVM/PrimOps.hs
index 0448d4d9..61910c83 100644
--- a/grin/src/Reducer/LLVM/PrimOps.hs
+++ b/grin/src/Reducer/LLVM/PrimOps.hs
@@ -2,6 +2,7 @@
 module Reducer.LLVM.PrimOps where
 
 import Control.Monad (when)
+import Data.Word
 import LLVM.AST
 import qualified LLVM.AST.IntegerPredicate as I
 import qualified LLVM.AST.FloatingPointPredicate as F
@@ -17,13 +18,13 @@ import Reducer.LLVM.TypeGen
 import Grin.PrimOpsPrelude
 
 
-cgUnit    = toCGType $ T_SimpleType T_Unit    :: CGType
-cgInt64   = toCGType $ T_SimpleType T_Int64   :: CGType
-cgWord64  = toCGType $ T_SimpleType T_Word64  :: CGType
-cgFloat   = toCGType $ T_SimpleType T_Float   :: CGType
-cgBool    = toCGType $ T_SimpleType T_Bool    :: CGType
-cgString  = toCGType $ T_SimpleType T_String  :: CGType
-cgChar    = toCGType $ T_SimpleType T_Char    :: CGType
+cgUnit    = toCGType $ T_SimpleType T_Unit     :: CGType
+cgInt w   = toCGType $ T_SimpleType $ T_Int w  :: CGType
+cgWord w  = toCGType $ T_SimpleType $ T_Word w :: CGType
+cgFloat   = toCGType $ T_SimpleType T_Float    :: CGType
+cgBool    = toCGType $ T_SimpleType T_Bool     :: CGType
+cgString  = toCGType $ T_SimpleType T_String   :: CGType
+cgChar    = toCGType $ T_SimpleType T_Char     :: CGType
 
 codeExternal :: Grin.External -> [Operand] -> CG Result
 codeExternal e ops = case Grin.eKind e of
@@ -33,11 +34,11 @@ codeExternal e ops = case Grin.eKind e of
 codeGenPrimOp :: Grin.Name -> [Operand] -> CG Result
 codeGenPrimOp name [opA, opB] = pure $ case name of
   -- Int
-  "_prim_int_add"   -> I cgInt64 $ Add  {nsw=False, nuw=False, operand0=opA, operand1=opB, metadata=[]}
-  "_prim_int_sub"   -> I cgInt64 $ Sub  {nsw=False, nuw=False, operand0=opA, operand1=opB, metadata=[]}
-  "_prim_int_mul"   -> I cgInt64 $ Mul  {nsw=False, nuw=False, operand0=opA, operand1=opB, metadata=[]}
-  "_prim_int_div"   -> I cgInt64 $ SDiv {exact=False, operand0=opA, operand1=opB, metadata=[]}
-  "_prim_int_ashr"  -> I cgInt64 $ AShr {exact=False, operand0=opA, operand1=opB, metadata=[]}
+  "_prim_int_add"   -> I (cgInt 64) $ Add  {nsw=False, nuw=False, operand0=opA, operand1=opB, metadata=[]}
+  "_prim_int_sub"   -> I (cgInt 64) $ Sub  {nsw=False, nuw=False, operand0=opA, operand1=opB, metadata=[]}
+  "_prim_int_mul"   -> I (cgInt 64) $ Mul  {nsw=False, nuw=False, operand0=opA, operand1=opB, metadata=[]}
+  "_prim_int_div"   -> I (cgInt 64) $ SDiv {exact=False, operand0=opA, operand1=opB, metadata=[]}
+  "_prim_int_ashr"  -> I (cgInt 64) $ AShr {exact=False, operand0=opA, operand1=opB, metadata=[]}
   "_prim_int_eq"    -> I cgBool  $ ICmp {iPredicate=I.EQ,  operand0=opA, operand1=opB, metadata=[]}
   "_prim_int_ne"    -> I cgBool  $ ICmp {iPredicate=I.NE,  operand0=opA, operand1=opB, metadata=[]}
   "_prim_int_gt"    -> I cgBool  $ ICmp {iPredicate=I.SGT, operand0=opA, operand1=opB, metadata=[]}
@@ -46,10 +47,10 @@ codeGenPrimOp name [opA, opB] = pure $ case name of
   "_prim_int_le"    -> I cgBool  $ ICmp {iPredicate=I.SLE, operand0=opA, operand1=opB, metadata=[]}
 
   -- Word
-  "_prim_word_add"  -> I cgWord64 $ Add  {nsw=False, nuw=False, operand0=opA, operand1=opB, metadata=[]}
-  "_prim_word_sub"  -> I cgWord64 $ Sub  {nsw=False, nuw=False, operand0=opA, operand1=opB, metadata=[]}
-  "_prim_word_mul"  -> I cgWord64 $ Mul  {nsw=False, nuw=False, operand0=opA, operand1=opB, metadata=[]}
-  "_prim_word_div"  -> I cgWord64 $ UDiv {exact=False, operand0=opA, operand1=opB, metadata=[]}
+  "_prim_word_add"  -> I (cgWord 64) $ Add  {nsw=False, nuw=False, operand0=opA, operand1=opB, metadata=[]}
+  "_prim_word_sub"  -> I (cgWord 64) $ Sub  {nsw=False, nuw=False, operand0=opA, operand1=opB, metadata=[]}
+  "_prim_word_mul"  -> I (cgWord 64) $ Mul  {nsw=False, nuw=False, operand0=opA, operand1=opB, metadata=[]}
+  "_prim_word_div"  -> I (cgWord 64) $ UDiv {exact=False, operand0=opA, operand1=opB, metadata=[]}
   "_prim_word_eq"   -> I cgBool   $ ICmp {iPredicate=I.EQ,  operand0=opA, operand1=opB, metadata=[]}
   "_prim_word_ne"   -> I cgBool   $ ICmp {iPredicate=I.NE,  operand0=opA, operand1=opB, metadata=[]}
   "_prim_word_gt"   -> I cgBool   $ ICmp {iPredicate=I.UGT, operand0=opA, operand1=opB, metadata=[]}
diff --git a/grin/src/Reducer/LLVM/TypeGen.hs b/grin/src/Reducer/LLVM/TypeGen.hs
index 6f6d30af..f3cfc530 100644
--- a/grin/src/Reducer/LLVM/TypeGen.hs
+++ b/grin/src/Reducer/LLVM/TypeGen.hs
@@ -36,8 +36,8 @@ stringType = ptr stringStructType
 
 typeGenSimpleType :: SimpleType -> LLVM.Type
 typeGenSimpleType = \case
-  T_Int64   -> i64
-  T_Word64  -> i64
+  T_Int w   -> IntegerType w
+  T_Word w  -> IntegerType w
   T_Float   -> float
   T_Bool    -> i1
   T_String  -> stringType
@@ -51,7 +51,7 @@ locationCGType :: CGType
 locationCGType = toCGType $ T_SimpleType $ T_Location []
 
 tagCGType :: CGType
-tagCGType = toCGType $ T_SimpleType $ T_Int64
+tagCGType = toCGType $ T_SimpleType $ T_Int 64
 
 unitCGType :: CGType
 unitCGType = toCGType $ T_SimpleType $ T_Unit
diff --git a/grin/src/Reducer/PrimOps.hs b/grin/src/Reducer/PrimOps.hs
index 61fc1100..501f4c4d 100644
--- a/grin/src/Reducer/PrimOps.hs
+++ b/grin/src/Reducer/PrimOps.hs
@@ -32,7 +32,7 @@ C.include "<math.h>"
 C.include "<stdio.h>"
 
 -- primitive functions
-primLiteralPrint _ _ [RT_Lit (LInt64 a)] = liftIO (putStr $ show a) >> pure RT_Unit
+primLiteralPrint _ _ [RT_Lit (LInt 64 a)] = liftIO (putStr $ show a) >> pure RT_Unit
 primLiteralPrint _ _ [RT_Lit (LString a)] = liftIO (putStr (Text.unpack a)) >> pure RT_Unit
 primLiteralPrint ctx ps x = error $ Prelude.unwords ["primLiteralPrint", ctx, "- invalid arguments:", show ps, " - ", show x]
 
@@ -103,23 +103,23 @@ evalPrimOp name params args = case name of
 
   _ -> error $ "unknown primitive operation: " ++ unpackName name
  where
-  int   x = pure . RT_Lit . LInt64 $ x
-  word  x = pure . RT_Lit . LWord64 $ x
+  int   x = pure . RT_Lit . (LInt 64) $ x
+  word  x = pure . RT_Lit . (LWord 64) $ x
   float x = pure . RT_Lit . LFloat $ x
   bool  x = pure . RT_Lit . LBool $ x
   string x = pure . RT_Lit . LString $ x
 --  char x = pure . RT_Lit . LChar $ x
 
   int_un_op retTy fn = case args of
-    [RT_Lit (LInt64 a)] -> retTy $ fn a
+    [RT_Lit (LInt 64 a)] -> retTy $ fn a
     _ -> error $ "invalid arguments: " ++ show params ++ " " ++ show args ++ " for " ++ unpackName name
 
   int_bin_op retTy fn = case args of
-    [RT_Lit (LInt64 a), RT_Lit (LInt64 b)] -> retTy $ fn a b
+    [RT_Lit (LInt 64 a), RT_Lit (LInt 64 b)] -> retTy $ fn a b
     _ -> error $ "invalid arguments: " ++ show params ++ " " ++ show args ++ " for " ++ unpackName name
 
   word_bin_op retTy fn = case args of
-    [RT_Lit (LWord64 a), RT_Lit (LWord64 b)] -> retTy $ fn a b
+    [RT_Lit (LWord 64 a), RT_Lit (LWord 64 b)] -> retTy $ fn a b
     _ -> error $ "invalid arguments: " ++ show params ++ " " ++ show args ++ " for " ++ unpackName name
 
   float_bin_op retTy fn = case args of
@@ -139,11 +139,11 @@ evalPrimOp name params args = case name of
     _ -> error $ "invalid arguments:" ++ show params ++ " " ++ show args ++ " for " ++ unpackName name
 
   string_cons = case args of
-    [RT_Lit (LInt64 a), RT_Lit (LString b)] -> string $ Text.cons (chr (fromIntegral a)) b
+    [RT_Lit (LInt 64 a), RT_Lit (LString b)] -> string $ Text.cons (chr (fromIntegral a)) b
     _ -> error $ "invalid arguments: " ++ show params ++ " " ++ show args ++ " for " ++ unpackName name
 
   int_str = case args of
-    [RT_Lit (LInt64 a)] -> string $ fromString $ show a
+    [RT_Lit (LInt 64 a)] -> string $ fromString $ show a
     _ -> error $ "invalid arguments:" ++ show params ++ " " ++ show args ++ " for " ++ unpackName name
 
   str_int = case args of
@@ -151,7 +151,7 @@ evalPrimOp name params args = case name of
     _ -> error $ "invalid arguments:" ++ show params ++ " " ++ show args ++ " for " ++ unpackName name
 
   int_float = case args of
-    [RT_Lit (LInt64 a)] -> float $ fromIntegral a
+    [RT_Lit (LInt 64 a)] -> float $ fromIntegral a
     _ -> error $ "invalid arguments:" ++ show params ++ " " ++ show args ++ " for " ++ unpackName name
 
   char_int = case args of
@@ -167,7 +167,7 @@ evalPrimOp name params args = case name of
     _ -> error $ "invalid arguments:" ++ show params ++ " " ++ show args ++ " for " ++ unpackName name
 
   file_eof = case args of
-    [RT_Lit (LInt64 0)] -> (fmap (\case { False -> 0; _ -> 1}) (liftIO (hIsEOF stdin))) >>= int
+    [RT_Lit (LInt 64 0)] -> (fmap (\case { False -> 0; _ -> 1}) (liftIO (hIsEOF stdin))) >>= int
     _ -> error $ "invalid arguments:" ++ show params ++ " " ++ show args ++ " for " ++ unpackName name
 
   primReadString = case args of
@@ -175,7 +175,7 @@ evalPrimOp name params args = case name of
     _ -> error $ "invalid arguments:" ++ show params ++ " " ++ show args ++ " for " ++ unpackName name
 
   primUSleep = case args of
-    [RT_Lit (LInt64 us)] -> liftIO $ threadDelay (fromIntegral us) >> pure RT_Unit
+    [RT_Lit (LInt 64 us)] -> liftIO $ threadDelay (fromIntegral us) >> pure RT_Unit
     _ -> error $ "invalid arguments:" ++ show params ++ " " ++ show args ++ " for " ++ unpackName name
 
   primError = case args of
diff --git a/grin/src/Test/ExtendedSyntax/Old/Test.hs b/grin/src/Test/ExtendedSyntax/Old/Test.hs
index 92090abf..c8af8353 100644
--- a/grin/src/Test/ExtendedSyntax/Old/Test.hs
+++ b/grin/src/Test/ExtendedSyntax/Old/Test.hs
@@ -38,6 +38,7 @@ import qualified Test.ExtendedSyntax.Old.Grammar as G
 import Data.Set (Set); import qualified Data.Set as Set
 import Data.Map (Map); import qualified Data.Map as Map
 import Data.List
+import Data.Word
 
 import Debug.Trace
 import Data.Text (pack)
@@ -140,7 +141,7 @@ changeLast e r             = EBind r (Var "cl") e
 
 firstBindR :: TestExpContext
 firstBindR = ("first bind right", second tr) where
-  tr e = changeLast (SReturn (Lit (LInt64 1))) e
+  tr e = changeLast (SReturn (Lit (LInt 64 1))) e
 
 middleBindR :: TestExpContext
 middleBindR = ("middle bind right", second tr) where
@@ -332,10 +333,10 @@ instance Arbitrary Eff where arbitrary = genericArbitraryU
 -- TODO: Remove
 data Type
   = TUnit -- TODO: Rename
-  | TInt
+  | TInt Word32
   | TFloat
   | TBool
-  | TWord
+  | TWord Word32
   | TLoc Type
   | TTag Name [Type] -- Only constant tags, only simple types, or variables with location info
   | TUnion (Set Type)
@@ -356,9 +357,9 @@ instance Arbitrary Grin.Type where
 
 simpleType :: GoalM Type
 simpleType = melements
-  [ TInt
+  [ TInt 64
   , TFloat
-  , TWord
+  , TWord 64
   , TUnit
   , TBool
   , TString
@@ -367,9 +368,9 @@ simpleType = melements
 
 primitiveType :: GoalM Type
 primitiveType = melements
-  [ TInt
+  [ TInt 64
   , TFloat
-  , TWord
+  , TWord 64
   , TBool
   , TString
   , TChar
@@ -387,8 +388,8 @@ class TypeOf t where
 
 instance TypeOf G.SimpleVal where
   typeOf = \case
-    G.Lit (LInt64 _)  -> TInt
-    G.Lit (LWord64 _) -> TWord
+    G.Lit (LInt w _)  -> TInt w
+    G.Lit (LWord w _) -> TWord w
     G.Lit (LFloat _)  -> TFloat
     G.Lit (LBool _)   -> TBool
     G.Lit (LString _) -> TString
@@ -404,7 +405,7 @@ instance TypeOf G.Val where
 
 instance TypeOf G.ExtraVal where
   typeOf = \case
-    G.Loc _ -> TLoc TInt -- TODO: More types...
+    G.Loc _ -> TLoc (TInt 64) -- TODO: More types...
 
 instance (TypeOf l, TypeOf r) => TypeOf (Either l r) where
   typeOf = either typeOf typeOf
@@ -461,8 +462,8 @@ initContext expGen = Context (Env mempty primitives mempty) mempty expGen
     primitives = Map.fromList [ (eName p, (tyToType <$> eArgsType p, tyToType $ eRetType p, [])) | p <- preludePurePrimOps ]
     tyToType = \case
       TySimple ty -> case ty of
-        T_Int64  -> TInt
-        T_Word64 -> TWord
+        T_Int w  -> TInt w
+        T_Word w -> TWord w
         T_Float  -> TFloat
         T_Bool   -> TBool
         T_Unit   -> TUnit
@@ -557,13 +558,13 @@ gEnv t = do
 
 gLiteral :: Type -> GoalM G.SimpleVal
 gLiteral = fmap G.Lit . \case
-  TInt   -> LInt64  <$> gen arbitrary
-  TFloat -> LFloat  <$> gen arbitrary
-  TWord  -> LWord64 <$> gen arbitrary
-  TBool  -> LBool   <$> gen arbitrary
+  TInt w  -> LInt w  <$> gen arbitrary
+  TFloat  -> LFloat  <$> gen arbitrary
+  TWord w -> LWord w <$> gen arbitrary
+  TBool   -> LBool   <$> gen arbitrary
   TString -> LString . fromString <$> gen (listOf alphaNumChar)
   TChar   -> LChar <$> gen alphaNumChar
-  _      -> mzero
+  _       -> mzero
   where
     alphaNumChar = elements $ ['a' .. 'z'] ++ ['0' .. '9']
 
@@ -572,12 +573,12 @@ varFromEnv t = (G.Var . G.Name <$> gEnv t)
 
 gSimpleVal :: Type -> GoalM G.SimpleVal
 gSimpleVal = \case
-  TInt   -> varFromEnv TInt `mplus` gLiteral TInt
-  TFloat -> varFromEnv TFloat `mplus` gLiteral TFloat
-  TWord  -> varFromEnv TWord `mplus` gLiteral TWord
-  TBool  -> varFromEnv TBool `mplus` gLiteral TBool
+  TInt w   -> varFromEnv (TInt w) `mplus` gLiteral (TInt w)
+  TFloat   -> varFromEnv TFloat `mplus` gLiteral TFloat
+  TWord w  -> varFromEnv (TWord w) `mplus` gLiteral (TWord w)
+  TBool    -> varFromEnv TBool `mplus` gLiteral TBool
   TString  -> varFromEnv TString `mplus` gLiteral TString
-  TChar  -> varFromEnv TChar `mplus` gLiteral TChar
+  TChar    -> varFromEnv TChar `mplus` gLiteral TChar
   (TLoc t) -> varFromEnv (TLoc t) -- Locations have no literals
   _      -> mzero
 
@@ -590,11 +591,11 @@ gNodeValue = \case
 
 gValue :: Type -> GoalM G.Val
 gValue = \case
-  TUnit          -> pure G.Unit
-  TInt            -> G.SimpleVal <$> gSimpleVal TInt
+  TUnit           -> pure G.Unit
+  TInt w          -> G.SimpleVal <$> gSimpleVal (TInt w)
   TFloat          -> G.SimpleVal <$> gSimpleVal TFloat
-  TWord           -> G.SimpleVal <$> gSimpleVal TWord
-  TLoc t        -> G.SimpleVal <$> gSimpleVal (TLoc t)
+  TWord w         -> G.SimpleVal <$> gSimpleVal (TWord w)
+  TLoc t          -> G.SimpleVal <$> gSimpleVal (TLoc t)
   TBool           -> G.SimpleVal <$> gSimpleVal TBool
   TString         -> G.SimpleVal <$> gSimpleVal TString
   TChar           -> G.SimpleVal <$> gSimpleVal TChar
diff --git a/grin/src/Test/Test.hs b/grin/src/Test/Test.hs
index 22401105..0f4b8a74 100644
--- a/grin/src/Test/Test.hs
+++ b/grin/src/Test/Test.hs
@@ -39,6 +39,7 @@ import qualified Test.Grammar as G
 import Data.Set (Set); import qualified Data.Set as Set
 import Data.Map (Map); import qualified Data.Map as Map
 import Data.List
+import Data.Word
 
 import Debug.Trace
 import Data.Text (pack)
@@ -139,7 +140,7 @@ changeLast e r             = EBind r (Var "cl") e
 
 firstBindR :: TestExpContext
 firstBindR = ("first bind right", second tr) where
-  tr e = changeLast (SReturn (Lit (LInt64 1))) e
+  tr e = changeLast (SReturn (Lit (LInt 64 1))) e
 
 middleBindR :: TestExpContext
 middleBindR = ("middle bind right", second tr) where
@@ -333,10 +334,10 @@ instance Arbitrary Eff where arbitrary = genericArbitraryU
 -- TODO: Remove
 data Type
   = TUnit -- TODO: Rename
-  | TInt
+  | TInt Word32
   | TFloat
   | TBool
-  | TWord
+  | TWord Word32
   | TLoc Type
   | TTag Name [Type] -- Only constant tags, only simple types, or variables with location info
   | TUnion (Set Type)
@@ -350,9 +351,9 @@ instance Arbitrary Grin.Type where arbitrary = genericArbitraryU
 
 simpleType :: GoalM Type
 simpleType = melements
-  [ TInt
+  [ TInt 64 -- TODO arbitrary type here
   , TFloat
-  , TWord
+  , TWord 64
   , TUnit
   , TBool
 --  , TLoc
@@ -362,9 +363,9 @@ simpleType = melements
 
 primitiveType :: GoalM Type
 primitiveType = melements
-  [ TInt
+  [ TInt 64
   , TFloat
-  , TWord
+  , TWord 64
   , TBool
 --  , TUnit
 --  , TLoc
@@ -384,8 +385,8 @@ class TypeOf t where
 
 instance TypeOf G.SimpleVal where
   typeOf = \case
-    G.Lit (LInt64 _)  -> TInt
-    G.Lit (LWord64 _) -> TWord
+    G.Lit (LInt w _)  -> TInt w
+    G.Lit (LWord w _) -> TWord w
     G.Lit (LFloat _)  -> TFloat
     G.Lit (LBool _)   -> TBool
     G.Lit (LString _) -> TString
@@ -402,7 +403,7 @@ instance TypeOf G.Val where
 
 instance TypeOf G.ExtraVal where
   typeOf = \case
-    G.Loc _ -> TLoc TInt -- TODO: More types...
+    G.Loc _ -> TLoc (TInt 64) -- TODO: More types...
 
 instance (TypeOf l, TypeOf r) => TypeOf (Either l r) where
   typeOf = either typeOf typeOf
@@ -459,8 +460,8 @@ initContext expGen = Context (Env mempty primitives mempty) mempty expGen
     primitives = Map.fromList [ (eName p, (tyToType <$> eArgsType p, tyToType $ eRetType p, [])) | p <- preludePurePrimOps ]
     tyToType = \case
       TySimple ty -> case ty of
-        T_Int64  -> TInt
-        T_Word64 -> TWord
+        T_Int w  -> TInt w
+        T_Word w -> TWord w
         T_Float  -> TFloat
         T_Bool   -> TBool
         T_Unit   -> TUnit
@@ -555,13 +556,13 @@ gEnv t = do
 
 gLiteral :: Type -> GoalM G.SimpleVal
 gLiteral = fmap G.Lit . \case
-  TInt   -> LInt64  <$> gen arbitrary
-  TFloat -> LFloat  <$> gen arbitrary
-  TWord  -> LWord64 <$> gen arbitrary
-  TBool  -> LBool   <$> gen arbitrary
+  TInt w  -> LInt w  <$> gen arbitrary
+  TFloat  -> LFloat  <$> gen arbitrary
+  TWord w -> LWord w <$> gen arbitrary
+  TBool   -> LBool   <$> gen arbitrary
   TString -> LString . fromString <$> gen (listOf alphaNumChar)
   TChar   -> LChar <$> gen alphaNumChar
-  _      -> mzero
+  _       -> mzero
   where
     alphaNumChar = elements $ ['a' .. 'z'] ++ ['0' .. '9']
 
@@ -570,14 +571,14 @@ varFromEnv t = (G.Var . G.Name <$> gEnv t)
 
 gSimpleVal :: Type -> GoalM G.SimpleVal
 gSimpleVal = \case
-  TInt   -> varFromEnv TInt `mplus` gLiteral TInt
-  TFloat -> varFromEnv TFloat `mplus` gLiteral TFloat
-  TWord  -> varFromEnv TWord `mplus` gLiteral TWord
-  TBool  -> varFromEnv TBool `mplus` gLiteral TBool
+  TInt w   -> varFromEnv (TInt w) `mplus` gLiteral (TInt w)
+  TFloat   -> varFromEnv TFloat `mplus` gLiteral TFloat
+  TWord w  -> varFromEnv (TWord w) `mplus` gLiteral (TWord w)
+  TBool    -> varFromEnv TBool `mplus` gLiteral TBool
   TString  -> varFromEnv TString `mplus` gLiteral TString
-  TChar  -> varFromEnv TChar `mplus` gLiteral TChar
+  TChar    -> varFromEnv TChar `mplus` gLiteral TChar
   (TLoc t) -> varFromEnv (TLoc t) -- Locations have no literals
-  _      -> mzero
+  _        -> mzero
 
 gNodeValue :: Type -> GoalM G.Val
 gNodeValue = \case
@@ -588,11 +589,11 @@ gNodeValue = \case
 
 gValue :: Type -> GoalM G.Val
 gValue = \case
-  TUnit          -> pure G.Unit
-  TInt            -> G.SimpleVal <$> gSimpleVal TInt
+  TUnit           -> pure G.Unit
+  TInt w          -> G.SimpleVal <$> gSimpleVal (TInt w)
   TFloat          -> G.SimpleVal <$> gSimpleVal TFloat
-  TWord           -> G.SimpleVal <$> gSimpleVal TWord
-  TLoc t        -> G.SimpleVal <$> gSimpleVal (TLoc t)
+  TWord w         -> G.SimpleVal <$> gSimpleVal (TWord w)
+  TLoc t          -> G.SimpleVal <$> gSimpleVal (TLoc t)
   TBool           -> G.SimpleVal <$> gSimpleVal TBool
   TString         -> G.SimpleVal <$> gSimpleVal TString
   TChar           -> G.SimpleVal <$> gSimpleVal TChar
diff --git a/grin/src/Transformations/ExtendedSyntax/Conversion.hs b/grin/src/Transformations/ExtendedSyntax/Conversion.hs
index ba6358bc..0cd4e9d8 100644
--- a/grin/src/Transformations/ExtendedSyntax/Conversion.hs
+++ b/grin/src/Transformations/ExtendedSyntax/Conversion.hs
@@ -55,8 +55,8 @@ instance Convertible Tag New.Tag where
 
 instance Convertible Lit New.Lit where
   convert = \case
-    LInt64 n  -> New.LInt64 n
-    LWord64 n -> New.LWord64 n
+    LInt w n  -> New.LInt w n
+    LWord w n -> New.LWord w n
     LFloat f  -> New.LFloat f
     LBool b   -> New.LBool b
     LString s -> New.LString s
@@ -64,8 +64,8 @@ instance Convertible Lit New.Lit where
 
 instance Convertible SimpleType New.SimpleType where
   convert = \case
-    T_Int64               -> New.T_Int64
-    T_Word64              -> New.T_Word64
+    T_Int w               -> New.T_Int w
+    T_Word w              -> New.T_Word w
     T_Float               -> New.T_Float
     T_Bool                -> New.T_Bool
     T_Unit                -> New.T_Unit