diff --git a/crates/aiken-lang/src/ast.rs b/crates/aiken-lang/src/ast.rs
index 2d59a8c7..2b6f0c9a 100644
--- a/crates/aiken-lang/src/ast.rs
+++ b/crates/aiken-lang/src/ast.rs
@@ -703,7 +703,7 @@ pub enum Pattern<Constructor, Type> {
     },
 
     /// A name given to a sub-pattern using the `as` keyword.
-    /// e.g. `assert #(1, [_, _] as the_list) = x`
+    /// e.g. `assert (1, [_, _] as the_list) = x`
     Assign {
         name: String,
         location: Span,
diff --git a/crates/aiken-lang/src/format.rs b/crates/aiken-lang/src/format.rs
index 716a1eff..ca5587d7 100644
--- a/crates/aiken-lang/src/format.rs
+++ b/crates/aiken-lang/src/format.rs
@@ -396,13 +396,9 @@ impl<'comments> Formatter<'comments> {
                 ..
             } => docvec![module, ".", name],
 
-            Constant::Tuple { elements, .. } => "#"
-                .to_doc()
-                .append(wrap_args(
-                    false,
-                    elements.iter().map(|e| (self.const_expr(e), false)),
-                ))
-                .group(),
+            Constant::Tuple { elements, .. } => {
+                wrap_args(false, elements.iter().map(|e| (self.const_expr(e), false))).group()
+            }
         }
     }
 
@@ -480,10 +476,9 @@ impl<'comments> Formatter<'comments> {
                 .append(break_("", " ").append(self.annotation(retrn)).nest(INDENT)),
 
             Annotation::Var { name, .. } => name.to_doc(),
-            Annotation::Tuple { elems, .. } => "#".to_doc().append(wrap_args(
-                false,
-                elems.iter().map(|t| (self.annotation(t), false)),
-            )),
+            Annotation::Tuple { elems, .. } => {
+                wrap_args(false, elems.iter().map(|t| (self.annotation(t), false)))
+            }
         }
         .group()
     }
@@ -768,13 +763,9 @@ impl<'comments> Formatter<'comments> {
                 ..
             } => self.record_update(constructor, spread, args),
 
-            UntypedExpr::Tuple { elems, .. } => "#"
-                .to_doc()
-                .append(wrap_args(
-                    false,
-                    elems.iter().map(|e| (self.wrap_expr(e), false)),
-                ))
-                .group(),
+            UntypedExpr::Tuple { elems, .. } => {
+                wrap_args(false, elems.iter().map(|e| (self.wrap_expr(e), false))).group()
+            }
 
             UntypedExpr::TupleIndex { index, tuple, .. } => {
                 let suffix = Ordinal(*index + 1).suffix().to_doc();
@@ -1500,13 +1491,9 @@ impl<'comments> Formatter<'comments> {
 
             Pattern::Discard { name, .. } => name.to_doc(),
 
-            Pattern::Tuple { elems, .. } => "#"
-                .to_doc()
-                .append(wrap_args(
-                    false,
-                    elems.iter().map(|e| (self.pattern(e), false)),
-                ))
-                .group(),
+            Pattern::Tuple { elems, .. } => {
+                wrap_args(false, elems.iter().map(|e| (self.pattern(e), false))).group()
+            }
 
             Pattern::List { elements, tail, .. } => {
                 let elements_document =
diff --git a/crates/aiken-lang/src/parser.rs b/crates/aiken-lang/src/parser.rs
index 4206104f..8eb38b3a 100644
--- a/crates/aiken-lang/src/parser.rs
+++ b/crates/aiken-lang/src/parser.rs
@@ -346,12 +346,14 @@ fn constant_value_parser() -> impl Parser<Token, ast::UntypedConstant, Error = P
                 }
             });
 
-        let constant_tuple_parser = just(Token::Hash)
-            .ignore_then(
-                r.clone()
-                    .separated_by(just(Token::Comma))
-                    .allow_trailing()
-                    .delimited_by(just(Token::LeftParen), just(Token::RightParen)),
+        let constant_tuple_parser = r
+            .clone()
+            .separated_by(just(Token::Comma))
+            .at_least(2)
+            .allow_trailing()
+            .delimited_by(
+                choice((just(Token::LeftParen), just(Token::NewLineLeftParen))),
+                just(Token::RightParen),
             )
             .map_with_span(|elements, span| ast::UntypedConstant::Tuple {
                 location: span,
@@ -897,12 +899,14 @@ pub fn expr_parser(
                 label,
             });
 
-        let tuple = just(Token::Hash)
-            .ignore_then(
-                r.clone()
-                    .separated_by(just(Token::Comma))
-                    .allow_trailing()
-                    .delimited_by(just(Token::LeftParen), just(Token::RightParen)),
+        let tuple = r
+            .clone()
+            .separated_by(just(Token::Comma))
+            .at_least(2)
+            .allow_trailing()
+            .delimited_by(
+                choice((just(Token::LeftParen), just(Token::NewLineLeftParen))),
+                just(Token::RightParen),
             )
             .map_with_span(|elems, span| expr::UntypedExpr::Tuple {
                 location: span,
@@ -1380,13 +1384,11 @@ pub fn type_parser() -> impl Parser<Token, ast::Annotation, Error = ParseError>
                 }
             }),
             // Tuple
-            just(Token::Hash)
-                .ignore_then(
-                    r.clone()
-                        .separated_by(just(Token::Comma))
-                        .allow_trailing()
-                        .delimited_by(just(Token::LeftParen), just(Token::RightParen)),
-                )
+            r.clone()
+                .separated_by(just(Token::Comma))
+                .at_least(2)
+                .allow_trailing()
+                .delimited_by(just(Token::LeftParen), just(Token::RightParen))
                 .map_with_span(|elems, span| ast::Annotation::Tuple {
                     location: span,
                     elems,
@@ -1607,13 +1609,10 @@ pub fn pattern_parser() -> impl Parser<Token, ast::UntypedPattern, Error = Parse
                     value,
                 }
             }),
-            just(Token::Hash)
-                .ignore_then(
-                    r.clone()
-                        .separated_by(just(Token::Comma))
-                        .allow_trailing()
-                        .delimited_by(just(Token::LeftParen), just(Token::RightParen)),
-                )
+            r.clone()
+                .separated_by(just(Token::Comma))
+                .allow_trailing()
+                .delimited_by(just(Token::LeftParen), just(Token::RightParen))
                 .map_with_span(|elems, span| ast::UntypedPattern::Tuple {
                     location: span,
                     elems,
diff --git a/crates/aiken-lang/src/tests/parser.rs b/crates/aiken-lang/src/tests/parser.rs
index f605339c..2038da78 100644
--- a/crates/aiken-lang/src/tests/parser.rs
+++ b/crates/aiken-lang/src/tests/parser.rs
@@ -1444,7 +1444,7 @@ fn record_create_unlabeled() {
 fn parse_tuple() {
     let code = indoc! {r#"
             fn foo() {
-              let tuple = #(1, 2, 3, 4)
+              let tuple = (1, 2, 3, 4)
               tuple.1st + tuple.2nd + tuple.3rd + tuple.4th
             }
         "#};
@@ -1454,27 +1454,27 @@ fn parse_tuple() {
         vec![ast::UntypedDefinition::Fn(Function {
             arguments: vec![],
             body: expr::UntypedExpr::Sequence {
-                location: Span::new((), 13..86),
+                location: Span::new((), 13..85),
                 expressions: vec![
                     expr::UntypedExpr::Assignment {
-                        location: Span::new((), 13..38),
+                        location: Span::new((), 13..37),
                         value: Box::new(expr::UntypedExpr::Tuple {
-                            location: Span::new((), 25..38),
+                            location: Span::new((), 25..37),
                             elems: vec![
                                 expr::UntypedExpr::Int {
-                                    location: Span::new((), 27..28),
+                                    location: Span::new((), 26..27),
                                     value: "1".to_string(),
                                 },
                                 expr::UntypedExpr::Int {
-                                    location: Span::new((), 30..31),
+                                    location: Span::new((), 29..30),
                                     value: "2".to_string(),
                                 },
                                 expr::UntypedExpr::Int {
-                                    location: Span::new((), 33..34),
+                                    location: Span::new((), 32..33),
                                     value: "3".to_string(),
                                 },
                                 expr::UntypedExpr::Int {
-                                    location: Span::new((), 36..37),
+                                    location: Span::new((), 35..36),
                                     value: "4".to_string(),
                                 },
                             ],
@@ -1487,45 +1487,45 @@ fn parse_tuple() {
                         annotation: None,
                     },
                     expr::UntypedExpr::BinOp {
-                        location: Span::new((), 41..86),
+                        location: Span::new((), 40..85),
                         name: ast::BinOp::AddInt,
                         left: Box::new(expr::UntypedExpr::BinOp {
-                            location: Span::new((), 41..74),
+                            location: Span::new((), 40..73),
                             name: ast::BinOp::AddInt,
                             left: Box::new(expr::UntypedExpr::BinOp {
-                                location: Span::new((), 41..62),
+                                location: Span::new((), 40..61),
                                 name: ast::BinOp::AddInt,
                                 left: Box::new(expr::UntypedExpr::TupleIndex {
-                                    location: Span::new((), 41..50),
+                                    location: Span::new((), 40..49),
                                     index: 0,
                                     tuple: Box::new(expr::UntypedExpr::Var {
-                                        location: Span::new((), 41..46),
+                                        location: Span::new((), 40..45),
                                         name: "tuple".to_string(),
                                     }),
                                 }),
                                 right: Box::new(expr::UntypedExpr::TupleIndex {
-                                    location: Span::new((), 53..62),
+                                    location: Span::new((), 52..61),
                                     index: 1,
                                     tuple: Box::new(expr::UntypedExpr::Var {
-                                        location: Span::new((), 53..58),
+                                        location: Span::new((), 52..57),
                                         name: "tuple".to_string(),
                                     }),
                                 }),
                             }),
                             right: Box::new(expr::UntypedExpr::TupleIndex {
-                                location: Span::new((), 65..74),
+                                location: Span::new((), 64..73),
                                 index: 2,
                                 tuple: Box::new(expr::UntypedExpr::Var {
-                                    location: Span::new((), 65..70),
+                                    location: Span::new((), 64..69),
                                     name: "tuple".to_string(),
                                 }),
                             }),
                         }),
                         right: Box::new(expr::UntypedExpr::TupleIndex {
-                            location: Span::new((), 77..86),
+                            location: Span::new((), 76..85),
                             index: 3,
                             tuple: Box::new(expr::UntypedExpr::Var {
-                                location: Span::new((), 77..82),
+                                location: Span::new((), 76..81),
                                 name: "tuple".to_string(),
                             }),
                         }),
@@ -1538,11 +1538,77 @@ fn parse_tuple() {
             public: false,
             return_annotation: None,
             return_type: (),
-            end_position: 87,
+            end_position: 86,
         })],
     )
 }
 
+#[test]
+fn parse_tuple2() {
+    let code = indoc! {r#"
+            fn foo() {
+              let a = foo(14)
+              (a, 42)
+            }
+        "#};
+
+    assert_definitions(
+        code,
+        vec![ast::UntypedDefinition::Fn(Function {
+            arguments: vec![],
+            body: expr::UntypedExpr::Sequence {
+                location: Span::new((), 13..38),
+                expressions: vec![
+                    expr::UntypedExpr::Assignment {
+                        location: Span::new((), 13..28),
+                        value: Box::new(expr::UntypedExpr::Call {
+                            arguments: vec![ast::CallArg {
+                                label: None,
+                                location: Span::new((), 25..27),
+                                value: expr::UntypedExpr::Int {
+                                    location: Span::new((), 25..27),
+                                    value: "14".to_string(),
+                                },
+                            }],
+                            fun: Box::new(expr::UntypedExpr::Var {
+                                location: Span::new((), 21..24),
+                                name: "foo".to_string(),
+                            }),
+                            location: Span::new((), 24..28),
+                        }),
+                        pattern: ast::Pattern::Var {
+                            location: Span::new((), 17..18),
+                            name: "a".to_string(),
+                        },
+                        kind: ast::AssignmentKind::Let,
+                        annotation: None,
+                    },
+                    expr::UntypedExpr::Tuple {
+                        location: Span::new((), 31..38),
+                        elems: vec![
+                            expr::UntypedExpr::Var {
+                                location: Span::new((), 32..33),
+                                name: "a".to_string(),
+                            },
+                            expr::UntypedExpr::Int {
+                                location: Span::new((), 35..37),
+                                value: "42".to_string(),
+                            },
+                        ],
+                    },
+                ],
+            },
+            doc: None,
+            location: Span::new((), 0..8),
+            name: "foo".to_string(),
+            public: false,
+            return_annotation: None,
+            return_type: (),
+            end_position: 39,
+        })],
+    );
+}
+
 #[test]
 fn plain_bytearray_literals() {
     let code = indoc! {r#"
diff --git a/crates/aiken-lang/src/tipo/pretty.rs b/crates/aiken-lang/src/tipo/pretty.rs
index c5c692ad..8dc9d29e 100644
--- a/crates/aiken-lang/src/tipo/pretty.rs
+++ b/crates/aiken-lang/src/tipo/pretty.rs
@@ -75,7 +75,7 @@ impl Printer {
 
             Type::Var { tipo: typ, .. } => self.type_var_doc(&typ.borrow()),
 
-            Type::Tuple { elems, .. } => self.args_to_aiken_doc(elems).surround("#(", ")"),
+            Type::Tuple { elems, .. } => self.args_to_aiken_doc(elems).surround("(", ")"),
         }
     }