diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 2acfc4cf86e3..b238941dccef 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -234,6 +234,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Tracked()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Tracked)
 
+    case class CaptureParam()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.CaptureParam)
+
     /** Used under pureFunctions to mark impure function types `A => B` in `FunctionWithMods` */
     case class Impure()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Impure)
   }
@@ -528,12 +530,13 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     TypeApply(Select(scalaDot(nme.caps), nme.capsOf), tp :: Nil)
 
   // Capture set variable `[C^]` becomes: `[C >: CapSet <: CapSet^{cap}]`
-  def makeCapsBound()(using Context): TypeBoundsTree =
-    TypeBoundsTree(
-      Select(scalaDot(nme.caps), tpnme.CapSet),
-      makeRetaining(
-        Select(scalaDot(nme.caps), tpnme.CapSet),
-        Nil, tpnme.retainsCap))
+  def makeCapsBound(refsL: List[Tree] = Nil, refsU: List[Tree] = Nil)(using Context): TypeBoundsTree =
+    val lower = refsL match
+      case Nil => Select(scalaDot(nme.caps), tpnme.CapSet)
+      case refsL => makeRetaining(Select(scalaDot(nme.caps), tpnme.CapSet), refsL, tpnme.retains)
+    val upper =
+      makeRetaining(Select(scalaDot(nme.caps), tpnme.CapSet), refsU, if refsU.isEmpty then tpnme.retainsCap else tpnme.retains)
+    TypeBoundsTree(lower, upper)
 
   def makeConstructor(tparams: List[TypeDef], vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(using Context): DefDef =
     DefDef(nme.CONSTRUCTOR, joinParams(tparams, vparamss), TypeTree(), rhs)
diff --git a/compiler/src/dotty/tools/dotc/core/Flags.scala b/compiler/src/dotty/tools/dotc/core/Flags.scala
index 0775b3caaf0c..4629c492f295 100644
--- a/compiler/src/dotty/tools/dotc/core/Flags.scala
+++ b/compiler/src/dotty/tools/dotc/core/Flags.scala
@@ -380,6 +380,9 @@ object Flags {
   /** Tracked modifier for class parameter / a class with some tracked parameters */
   val (Tracked @ _, _, Dependent @ _) = newFlags(46, "tracked")
 
+  /** Cap modifier for capture-set parameters and capture-set members */
+  val (_, _, CaptureParam @ _) = newFlags(47, "cap")
+
   // ------------ Flags following this one are not pickled ----------------------------------
 
   /** Symbol is not a member of its owner */
diff --git a/compiler/src/dotty/tools/dotc/core/Mode.scala b/compiler/src/dotty/tools/dotc/core/Mode.scala
index 6fd76e37977d..571a786e9106 100644
--- a/compiler/src/dotty/tools/dotc/core/Mode.scala
+++ b/compiler/src/dotty/tools/dotc/core/Mode.scala
@@ -91,6 +91,14 @@ object Mode {
    */
   val ImplicitExploration: Mode = newMode(12, "ImplicitExploration")
 
+  /** We are currently inside a capture set.
+   *  A term name could be a capture variable, so we need to
+   *  check that it is valid to use as type name.
+   *  Since this mode is only used during annotation typing,
+   *  we can reuse the value of `ImplicitExploration` to save bits.
+   */
+  val InCaptureSet: Mode = ImplicitExploration
+
   /** We are currently unpickling Scala2 info */
   val Scala2Unpickling: Mode = newMode(13, "Scala2Unpickling")
 
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index 90e5544f19af..9d9f030f4522 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -443,6 +443,7 @@ object StdNames {
     val bytes: N                = "bytes"
     val canEqual_ : N           = "canEqual"
     val canEqualAny : N         = "canEqualAny"
+    val cap: N                  = "cap"
     val caps: N                 = "caps"
     val capsOf: N               = "capsOf"
     val captureChecking: N      = "captureChecking"
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 20eb6e9b33fa..bc101dc52072 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -35,6 +35,7 @@ import config.SourceVersion.*
 import config.SourceVersion
 import dotty.tools.dotc.config.MigrationVersion
 import dotty.tools.dotc.util.chaining.*
+import dotty.tools.dotc.config.Feature.ccEnabled
 
 object Parsers {
 
@@ -220,6 +221,10 @@ object Parsers {
     def isErased = isIdent(nme.erased) && in.erasedEnabled
     // Are we seeing an `erased` soft keyword that will not be an identifier?
     def isErasedKw = isErased && in.isSoftModifierInParamModifierPosition
+    // Are we seeing a `cap` soft keyword for declaring a capture-set member or at the beginning a capture-variable parameter list?
+    def isCapKw = Feature.ccEnabled && isIdent(nme.cap)
+    // 'cap type' ?
+    def isCapTypeKw = isCapKw && in.lookahead.token == TYPE
     def isSimpleLiteral =
       simpleLiteralTokens.contains(in.token)
       || isIdent(nme.raw.MINUS) && numericLitTokens.contains(in.lookahead.token)
@@ -1601,7 +1606,7 @@ object Parsers {
     }
 
     /** CaptureRef  ::=  { SimpleRef `.` } SimpleRef [`*`]
-     *                |  [ { SimpleRef `.` } SimpleRef `.` ] id `^`
+     *                |  [ { SimpleRef `.` } SimpleRef `.` ] id
      */
     def captureRef(): Tree =
       val ref = dotSelectors(simpleRef())
@@ -1609,12 +1614,6 @@ object Parsers {
         in.nextToken()
         atSpan(startOffset(ref)):
           PostfixOp(ref, Ident(nme.CC_REACH))
-      else if isIdent(nme.UPARROW) then
-        in.nextToken()
-        atSpan(startOffset(ref)):
-          convertToTypeId(ref) match
-            case ref: RefTree => makeCapsOf(ref)
-            case ref => ref
       else ref
 
     /**  CaptureSet ::=  `{` CaptureRef {`,` CaptureRef} `}`    -- under captureChecking
@@ -1909,7 +1908,7 @@ object Parsers {
         refinedTypeRest(atSpan(startOffset(t)) {
           RefinedTypeTree(rejectWildcardType(t), refinement(indentOK = true))
         })
-      else if Feature.ccEnabled && in.isIdent(nme.UPARROW) && isCaptureUpArrow then
+      else if Feature.ccEnabled && in.isIdent(nme.UPARROW) && isCaptureUpArrow then // TODO remove
         atSpan(t.span.start):
           in.nextToken()
           if in.token == LBRACE
@@ -1964,7 +1963,8 @@ object Parsers {
 
     def typeBlockStats(): List[Tree] =
       val tdefs = new ListBuffer[Tree]
-      while in.token == TYPE do tdefs += typeBlockStat()
+      while (in.token == TYPE) do
+        tdefs += typeBlockStat()
       tdefs.toList
 
     /**  TypeBlockStat ::= ‘type’ {nl} TypeDef
@@ -2165,11 +2165,14 @@ object Parsers {
      *    NamesAndTypes     ::=  NameAndType {‘,’ NameAndType}
      *    NameAndType       ::=  id ':' Type
      */
-    def argTypes(namedOK: Boolean, wildOK: Boolean, tupleOK: Boolean): List[Tree] =
-      def argType() =
-        val t = typ()
+    def argTypes(namedOK: Boolean, wildOK: Boolean, tupleOK: Boolean): List[Tree] = //TOOD grammar doc
+      def withWildCard(gen: => Tree) =
+        val t = gen
         if wildOK then t else rejectWildcardType(t)
 
+      def argType() = withWildCard(typ())
+      def argOrCapType() = withWildCard(if in.token == LBRACE then concreteCapsType(captureSet()) else typ())
+
       def namedArgType() =
         atSpan(in.offset):
           val name = ident()
@@ -2180,14 +2183,14 @@ object Parsers {
         atSpan(in.offset):
           val name = ident()
           acceptColon()
-          NamedArg(name, argType())
+          NamedArg(name, argType()) // TODO allow capsets here?
 
-      if namedOK && isIdent && in.lookahead.token == EQUALS then
-        commaSeparated(() => namedArgType())
+      if namedOK && isIdent && in.lookahead.token == EQUALS then // TOOD support for named cap args
+          commaSeparated(() => namedArgType())
       else if tupleOK && isIdent && in.lookahead.isColon && sourceVersion.enablesNamedTuples then
         commaSeparated(() => namedElem())
       else
-        commaSeparated(() => argType())
+        commaSeparated(() => argOrCapType())
     end argTypes
 
     def paramTypeOf(core: () => Tree): Tree =
@@ -2246,7 +2249,7 @@ object Parsers {
         inBraces(refineStatSeq())
 
     /** TypeBounds ::= [`>:' Type] [`<:' Type]
-     *              |  `^`                     -- under captureChecking
+     *              |  `^`                     -- under captureChecking TODO remove
      */
     def typeBounds(): TypeBoundsTree =
       atSpan(in.offset):
@@ -2256,10 +2259,29 @@ object Parsers {
         else
           TypeBoundsTree(bound(SUPERTYPE), bound(SUBTYPE))
 
+    /** CaptureSetBounds ::= [`>:' CaptureSetOrRef ] [`<:' CaptureSetOrRef ] --- under captureChecking
+     */
+    def captureSetBounds(): TypeBoundsTree =
+      atSpan(in.offset):
+          TypeBoundsTree(capsBound(SUPERTYPE), capsBound(SUBTYPE))
+
     private def bound(tok: Int): Tree =
       if (in.token == tok) { in.nextToken(); toplevelTyp() }
       else EmptyTree
 
+    private def capsBound(refs: List[Tree], isLowerBound: Boolean = false): Tree =
+      if isLowerBound && refs.isEmpty then // lower bounds with empty capture sets become a pure CapSet
+        Select(scalaDot(nme.caps), tpnme.CapSet)
+      else
+        makeRetaining(Select(scalaDot(nme.caps), tpnme.CapSet), refs, if refs.isEmpty then tpnme.retainsCap else tpnme.retains)
+
+    private def capsBound(tok: Int): Tree =
+      if (in.token == tok) then
+        in.nextToken()
+        capsBound(captureSet(), isLowerBound = tok == SUPERTYPE)
+      else
+        capsBound(Nil, isLowerBound = tok == SUPERTYPE)
+
     /** TypeAndCtxBounds  ::=  TypeBounds [`:` ContextBounds]
      */
     def typeAndCtxBounds(pname: TypeName): Tree = {
@@ -2269,6 +2291,15 @@ object Parsers {
       else atSpan((t.span union cbs.head.span).start) { ContextBounds(t, cbs) }
     }
 
+    /** CaptureSetAndCtxBounds  ::=  CaptureSetBounds [`:` ContextBounds]   -- under captureChecking
+     */
+    def captureSetAndCtxBounds(pname: TypeName): Tree = {
+      val t = captureSetBounds()
+      val cbs = contextBounds(pname)
+      if (cbs.isEmpty) t
+      else atSpan((t.span union cbs.head.span).start) { ContextBounds(t, cbs) }
+    }
+
     /** ContextBound      ::=  Type [`as` id] */
     def contextBound(pname: TypeName): Tree =
       val t = toplevelTyp(inContextBound = true)
@@ -2788,7 +2819,10 @@ object Parsers {
           in.nextToken()
           simpleExprRest(selectorOrMatch(t), location, canApply = true)
         case LBRACKET =>
-          val tapp = atSpan(startOffset(t), in.offset) { TypeApply(t, typeArgs(namedOK = true, wildOK = false)) }
+          val tapp = atSpan(startOffset(t), in.offset) {
+            val args = typeArgs(namedOK = true, wildOK = false)
+            TypeApply(t, args)
+          }
           simpleExprRest(tapp, location, canApply = true)
         case LPAREN | LBRACE | INDENT if canApply =>
           val app = atSpan(startOffset(t), in.offset) { mkApply(t, argumentExprs()) }
@@ -3311,6 +3345,7 @@ object Parsers {
           case nme.transparent => Mod.Transparent()
           case nme.infix => Mod.Infix()
           case nme.tracked => Mod.Tracked()
+          case nme.cap => Mod.CaptureParam()
         }
     }
 
@@ -3378,7 +3413,7 @@ object Parsers {
      *                  |  override
      *                  |  opaque
      *  LocalModifier  ::= abstract | final | sealed | open | implicit | lazy | erased |
-     *                     inline | transparent | infix
+     *                     inline | transparent | infix | cap
      */
     def modifiers(allowed: BitSet = modifierTokens, start: Modifiers = Modifiers()): Modifiers = {
       @tailrec
@@ -3467,7 +3502,6 @@ object Parsers {
       recur(numLeadParams, firstClause = true, prevIsTypeClause = false)
     end typeOrTermParamClauses
 
-
     /** ClsTypeParamClause::=  ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’
      *  ClsTypeParam      ::=  {Annotation} [‘+’ | ‘-’]
      *                         id [HkTypeParamClause] TypeAndCtxBounds
@@ -3492,6 +3526,43 @@ object Parsers {
         in.nextToken()
         ok
 
+      def ensureNoHKParams() = // for cap params
+        if in.token == LBRACKET then
+          syntaxError(em"'cap' parameters cannot have type parameters")
+          in.nextToken()
+
+      def ensureNoVariance() = // for cap params
+        if isIdent(nme.raw.PLUS) || isIdent(nme.raw.MINUS) then
+          syntaxError(em"no `+/-` variance annotation allowed here")
+          in.nextToken()
+
+      def typeOrCapParam(): TypeDef =
+        if isCapKw then
+          in.nextToken()
+          capParam()
+        else typeParam()
+
+      def capParam(): TypeDef = {
+        val start = in.offset
+        var mods = annotsAsMods() | Param
+        if paramOwner.isClass then
+          mods |= PrivateLocal
+        ensureNoVariance() // TODO: in the future, we might want to support variances on capture params, ruled out for now
+        atSpan(start, nameStart) {
+          val name =
+            if paramOwner.acceptsWildcard && in.token == USCORE then
+              in.nextToken()
+              WildcardParamName.fresh().toTypeName
+            else ident().toTypeName
+          ensureNoHKParams()
+          val bounds =
+            if paramOwner.acceptsCtxBounds then captureSetAndCtxBounds(name)
+            else if sourceVersion.enablesNewGivens && paramOwner == ParamOwner.Type then captureSetAndCtxBounds(name)
+            else captureSetBounds()
+          TypeDef(name, bounds).withMods(mods)
+        }
+      }
+
       def typeParam(): TypeDef = {
         val start = in.offset
         var mods = annotsAsMods() | Param
@@ -3515,11 +3586,14 @@ object Parsers {
           TypeDef(name, lambdaAbstract(hkparams, bounds)).withMods(mods)
         }
       }
-      commaSeparated(() => typeParam())
+      commaSeparated(() => typeOrCapParam())
     }
 
     def typeParamClauseOpt(paramOwner: ParamOwner): List[TypeDef] =
-      if (in.token == LBRACKET) typeParamClause(paramOwner) else Nil
+      if (in.token == LBRACKET)
+        typeParamClause(paramOwner)
+      else
+        Nil
 
     /** ContextTypes   ::=  FunArgType {‘,’ FunArgType}
      */
@@ -3861,25 +3935,29 @@ object Parsers {
      *             | var VarDef
      *             | def DefDef
      *             | type {nl} TypeDef
+     *             | cap type {nl} CapDef     -- under capture checking
      *             | TmplDef
      *  EnumCase ::= `case' (id ClassConstr [`extends' ConstrApps]] | ids)
      */
-    def defOrDcl(start: Int, mods: Modifiers): Tree = in.token match {
-      case VAL =>
-        in.nextToken()
-        patDefOrDcl(start, mods)
-      case VAR =>
-        val mod = atSpan(in.skipToken()) { Mod.Var() }
-        val mod1 = addMod(mods, mod)
-        patDefOrDcl(start, mod1)
-      case DEF =>
-        defDefOrDcl(start, in.skipToken(mods))
-      case TYPE =>
-        typeDefOrDcl(start, in.skipToken(mods))
-      case CASE if inEnum =>
-        enumCase(start, mods)
-      case _ =>
-        tmplDef(start, mods)
+    def defOrDcl(start: Int, mods: Modifiers): Tree =
+      in.token match {
+        case VAL =>
+          in.nextToken()
+          patDefOrDcl(start, mods)
+        case VAR =>
+          val mod = atSpan(in.skipToken()) { Mod.Var() }
+          val mod1 = addMod(mods, mod)
+          patDefOrDcl(start, mod1)
+        case DEF =>
+          defDefOrDcl(start, in.skipToken(mods))
+        case TYPE if mods.is(CaptureParam) =>
+          capDefOrDcl(start, in.skipToken(mods))
+        case TYPE =>
+          typeDefOrDcl(start, in.skipToken(mods))
+        case CASE if inEnum =>
+          enumCase(start, mods)
+        case _ =>
+          tmplDef(start, mods)
     }
 
     /** PatDef  ::=  ids [‘:’ Type] [‘=’ Expr]
@@ -4088,6 +4166,43 @@ object Parsers {
       }
     }
 
+    private def concreteCapsType(refs: List[Tree]): Tree =
+      makeRetaining(Select(scalaDot(nme.caps), tpnme.CapSet), refs, tpnme.retains)
+
+    /** CapDef ::=  id CaptureSetAndCtxBounds [‘=’ CaptureSetOrRef]    -- under capture checking
+     */
+    def capDefOrDcl(start: Offset, mods: Modifiers): Tree =
+      newLinesOpt()
+      atSpan(start, nameStart) {
+        val nameIdent = typeIdent()
+        val tname = nameIdent.name.asTypeName
+        if in.token == LBRACKET then syntaxError(em"'cap type' declarations cannot have type parameters")
+
+        def makeCapDef(refs: List[Tree] | Tree): Tree = {
+          val tdef = TypeDef(nameIdent.name.toTypeName,
+                             refs.match
+                                case refs: List[Tree] => concreteCapsType(refs)
+                                case bounds: Tree => bounds)
+
+          if (nameIdent.isBackquoted)
+            tdef.pushAttachment(Backquoted, ())
+          finalizeDef(tdef, mods, start)
+        }
+
+        in.token.match
+          case EQUALS =>
+            in.nextToken()
+            makeCapDef(captureSet())
+          case SUBTYPE | SUPERTYPE | SEMI | NEWLINE | NEWLINES | COMMA | RBRACE | OUTDENT | EOF =>
+            makeCapDef(captureSetAndCtxBounds(tname))
+          case _ if (staged & StageKind.QuotedPattern) != 0
+              || sourceVersion.enablesNewGivens && in.isColon =>
+            makeCapDef(captureSetAndCtxBounds(tname))
+          case _ =>
+            syntaxErrorOrIncomplete(ExpectedCaptureBoundOrEquals(in.token))
+            return EmptyTree // return to avoid setting the span to EmptyTree
+      }
+
     /** TmplDef ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
      *            |  [‘case’] ‘object’ ObjectDef
      *            |  ‘enum’ EnumDef
@@ -4681,6 +4796,7 @@ object Parsers {
      *                     |  ‘var’ VarDef
      *                     |  ‘def’ DefDef
      *                     |  ‘type’ {nl} TypeDef
+     *                     |  ‘cap’ ‘type’ {nl} CapDef -- under capture checking
      *  (in reality we admit class defs and vars and filter them out afterwards in `checkLegal`)
      */
     def refineStatSeq(): List[Tree] = {
@@ -4705,9 +4821,14 @@ object Parsers {
             fail(em"this kind of definition cannot be a refinement")
 
       while
+        val mods =
+          if isCapTypeKw then // allow `cap type` in refinements
+            in.nextToken()
+            addMod(Modifiers(), Mod.CaptureParam())
+          else Modifiers()
         val dclFound = isDclIntro
         if dclFound then
-          stats ++= checkLegal(defOrDcl(in.offset, Modifiers()))
+          stats ++= checkLegal(defOrDcl(in.offset, mods))
         var what = "declaration"
         if inFunReturnType then what += " (possible cause: missing `=` in front of current method body)"
         statSepOrEnd(stats, noPrevStat = !dclFound, what)
diff --git a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
index ed20c189796b..32befcf1cd22 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
@@ -1209,7 +1209,7 @@ object Scanners {
 
     def isSoftModifier: Boolean =
       token == IDENTIFIER
-      && (softModifierNames.contains(name) || name == nme.erased && erasedEnabled || name == nme.tracked && trackedEnabled)
+      && (softModifierNames.contains(name) || name == nme.erased && erasedEnabled || name == nme.tracked && trackedEnabled || name == nme.cap && Feature.ccEnabled)
 
     def isSoftModifierInModifierPosition: Boolean =
       isSoftModifier && inModifierPosition()
diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
index 8f8f4676f43b..264ce47cb8ef 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
@@ -222,6 +222,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case EnumMayNotBeValueClassesID // errorNumber: 206
   case IllegalUnrollPlacementID // errorNumber: 207
   case ExtensionHasDefaultID // errorNumber: 208
+  case ExpectedCaptureBoundOrEqualsID // errorNumber: 209
 
   def errorNumber = ordinal - 1
 
diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index b5d67f0808b2..3d1db061f677 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -1917,6 +1917,23 @@ class ExpectedTypeBoundOrEquals(found: Token)(using Context)
         |"""
 }
 
+class ExpectedCaptureBoundOrEquals(found: Token)(using Context)
+  extends SyntaxMsg(ExpectedCaptureBoundOrEqualsID) {
+  def msg(using Context) = i"${hl("=")}, ${hl(">:")}, or ${hl("<:")} expected, but ${Tokens.showToken(found)} found"
+
+  def explain(using Context) =
+    i"""Capture parameters and abstract captures may be constrained by a capture bound.
+        |Such capture bounds limit the concrete values of the capture variables and possibly
+        |reveal more information about the members of such captures.
+        |
+        |A lower type bound ${hl("B >: A")} expresses that the capture variable ${hl("B")}
+        |refers to a super capture of capture ${hl("A")}.
+        |
+        |An upper capture bound ${hl("T <: A")} declares that capture variable ${hl("T")}
+        |refers to a subcapture of ${hl("A")}.
+        |"""
+}
+
 class ClassAndCompanionNameClash(cls: Symbol, other: Symbol)(using Context)
   extends NamingMsg(ClassAndCompanionNameClashID) {
   def msg(using Context) =
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 71fc250d0710..381643a1cfbd 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -36,6 +36,7 @@ import annotation.threadUnsafe
 
 import scala.util.control.NonFatal
 import dotty.tools.dotc.inlines.Inlines
+import dotty.tools.dotc.cc.isRetains
 
 object Applications {
   import tpd.*
@@ -1115,7 +1116,9 @@ trait Applications extends Compatibility {
             val fun2 = Applications.retypeSignaturePolymorphicFn(fun1, methType)
             simpleApply(fun2, proto)
           case funRef: TermRef =>
-            val app = ApplyTo(tree, fun1, funRef, proto, pt)
+            // println(i"typedApply: $funRef, ${tree.args}, ${funRef.symbol.maybeOwner.isRetains}")
+            val applyCtx = if funRef.symbol.maybeOwner.isRetains then ctx.addMode(Mode.InCaptureSet) else ctx
+            val app = ApplyTo(tree, fun1, funRef, proto, pt)(using applyCtx)
             convertNewGenericArray(
               widenEnumCase(
                 postProcessByNameArgs(funRef, app).computeNullable(),
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index be3186720fa1..3719c3d93250 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -715,6 +715,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         && ctx.owner.owner.unforcedDecls.lookup(tree.name).exists
     then // we are in the arguments of a this(...) constructor call
       errorTree(tree, em"$tree is not accessible from constructor arguments")
+    else if name.isTermName && ctx.mode.is(Mode.InCaptureSet) then
+      // If we are in a capture set and the identifier is not a term name,
+      // try to type it with the same name but as a type
+      typed(untpd.makeCapsOf(untpd.cpy.Ident(tree)(name.toTypeName)), pt)
     else
       errorTree(tree, MissingIdent(tree, kind, name, pt))
   end typedIdent
@@ -920,6 +924,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         typedCBSelect(tree0, pt, qual)
       else EmptyTree
 
+    // Otherwise, if we are in a capture set, try to type it as a capture variable
+    // reference (as selecting a type name).
+    def trySelectTypeInCaptureSet() =
+      if tree0.name.isTermName && ctx.mode.is(Mode.InCaptureSet) then
+        typedSelectWithAdapt(untpd.cpy.Select(tree0)(qual, tree0.name.toTypeName), pt, qual)
+      else EmptyTree
+
     // Otherwise, report an error
     def reportAnError() =
       assignType(tree,
@@ -941,6 +952,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       .orElse(tryDynamic())
       .orElse(trySelectable())
       .orElse(tryCBCompanion())
+      .orElse(trySelectTypeInCaptureSet())
       .orElse(reportAnError())
   end typedSelectWithAdapt
 
diff --git a/tests/neg-custom-args/captures/capset-bound.scala b/tests/neg-custom-args/captures/capset-bound.scala
index c00f61240dea..80ee3804776f 100644
--- a/tests/neg-custom-args/captures/capset-bound.scala
+++ b/tests/neg-custom-args/captures/capset-bound.scala
@@ -5,7 +5,7 @@ class IO
 case class File(io: IO^)
 
 def test(io1: IO^, io2: IO^) =
-  def f[C >: CapSet^{io1} <: CapSet^](file: File^{C^}) = ???
+  def f[C >: CapSet^{io1} <: CapSet^](file: File^{C}) = ???
   val f1: File^{io1} = ???
   val f2: File^{io2} = ???
   val f3: File^{io1, io2} = ???
diff --git a/tests/neg-custom-args/captures/capset-bound2.scala b/tests/neg-custom-args/captures/capset-bound2.scala
index 679606f0e43c..4cee6b244de7 100644
--- a/tests/neg-custom-args/captures/capset-bound2.scala
+++ b/tests/neg-custom-args/captures/capset-bound2.scala
@@ -2,7 +2,7 @@ import caps.*
 
 class IO
 
-def f[C^](io: IO^{C^}) = ???
+def f[C^](io: IO^{C}) = ???
 
 def test =
   f[CapSet](???)
@@ -10,4 +10,3 @@ def test =
   f[CapSet^](???)
   f[Nothing](???) // error
   f[String](???) // error
-  
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/capset-members.scala b/tests/neg-custom-args/captures/capset-members.scala
index 540216852a43..9d197a206e95 100644
--- a/tests/neg-custom-args/captures/capset-members.scala
+++ b/tests/neg-custom-args/captures/capset-members.scala
@@ -1,30 +1,29 @@
 import caps.*
 
-trait Abstract[X^]:
-  type C >: X <: CapSet^
+trait Abstract[cap X]:
+  cap type C >: {X}
   // Don't test the return type using Unit, because it is a pure type.
-  def boom(): AnyRef^{C^}
+  def boom(): AnyRef^{C}
 
-class Concrete extends Abstract[CapSet^{}]:
-  type C = CapSet^{}
+class Concrete extends Abstract[{}]:
+  cap type C = {}
   // TODO: Why do we get error without the return type here?
   def boom(): AnyRef = new Object
 
-class Concrete2 extends Abstract[CapSet^{}]:
-  type C = CapSet^{}
+class Concrete2 extends Abstract[{}]:
+  cap type C = {}
   def boom(): AnyRef^ = new Object // error
 
-class Concrete3 extends Abstract[CapSet^{}]:
+class Concrete3 extends Abstract[{}]:
   def boom(): AnyRef = new Object
 
-class Concrete4(a: AnyRef^) extends Abstract[CapSet^{a}]:
-  type C = CapSet // error
+class Concrete4(a: AnyRef^) extends Abstract[{a}]:
+  cap type C = {} // error
   def boom(): AnyRef^{a} = a // error
 
-class Concrete5(a: AnyRef^, b: AnyRef^) extends Abstract[CapSet^{a}]:
-  type C = CapSet^{a}
+class Concrete5(a: AnyRef^, b: AnyRef^) extends Abstract[{a}]:
+  cap type C = {a}
   def boom(): AnyRef^{b} = b // error
 
-class Concrete6(a: AnyRef^, b: AnyRef^) extends Abstract[CapSet^{a}]:
-  def boom(): AnyRef^{b} = b // error
-  
\ No newline at end of file
+class Concrete6(a: AnyRef^, b: AnyRef^) extends Abstract[{a}]:
+  def boom(): AnyRef^{b} = b // error
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/capset-members2.check b/tests/neg-custom-args/captures/capset-members2.check
new file mode 100644
index 000000000000..6e67ce3d39a3
--- /dev/null
+++ b/tests/neg-custom-args/captures/capset-members2.check
@@ -0,0 +1,4 @@
+-- Error: tests/neg-custom-args/captures/capset-members2.scala:4:12 ----------------------------------------------------
+4 |  cap type C[T] // error
+  |            ^
+  |            'cap type' declarations cannot have type parameters
diff --git a/tests/neg-custom-args/captures/capset-members2.scala b/tests/neg-custom-args/captures/capset-members2.scala
new file mode 100644
index 000000000000..ab8fab3716d8
--- /dev/null
+++ b/tests/neg-custom-args/captures/capset-members2.scala
@@ -0,0 +1,5 @@
+import caps.*
+
+trait Foo:
+  cap type C[T] // error
+
diff --git a/tests/neg-custom-args/captures/capset-members3.check b/tests/neg-custom-args/captures/capset-members3.check
new file mode 100644
index 000000000000..74d3cf82f78e
--- /dev/null
+++ b/tests/neg-custom-args/captures/capset-members3.check
@@ -0,0 +1,6 @@
+-- [E209] Syntax Error: tests/neg-custom-args/captures/capset-members3.scala:4:13 --------------------------------------
+4 |  cap type C _ // error
+  |             ^
+  |             =, >:, or <: expected, but '_' found
+  |
+  | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/capset-members3.scala b/tests/neg-custom-args/captures/capset-members3.scala
new file mode 100644
index 000000000000..02e377a8d553
--- /dev/null
+++ b/tests/neg-custom-args/captures/capset-members3.scala
@@ -0,0 +1,5 @@
+import caps.*
+
+trait Foo:
+  cap type C _ // error
+
diff --git a/tests/neg-custom-args/captures/capture-parameters.scala b/tests/neg-custom-args/captures/capture-parameters.scala
index d59305ae0cb8..d9288a062ded 100644
--- a/tests/neg-custom-args/captures/capture-parameters.scala
+++ b/tests/neg-custom-args/captures/capture-parameters.scala
@@ -2,8 +2,7 @@ import caps.*
 
 class C
 
-def test[X^, Y^, Z >: X <: Y](x: C^{X^}, y: C^{Y^}, z: C^{Z^}) =
-  val x2z: C^{Z^} = x
-  val z2y: C^{Y^} = z
-  val x2y: C^{Y^} = x // error
-  
\ No newline at end of file
+def test[X^, Y^, Z >: X <: Y](x: C^{X}, y: C^{Y}, z: C^{Z}) =
+  val x2z: C^{Z} = x
+  val z2y: C^{Y} = z
+  val x2y: C^{Y} = x // error
diff --git a/tests/neg-custom-args/captures/capture-poly.scala b/tests/neg-custom-args/captures/capture-poly.scala
index 88989b418726..9276eab0342f 100644
--- a/tests/neg-custom-args/captures/capture-poly.scala
+++ b/tests/neg-custom-args/captures/capture-poly.scala
@@ -5,8 +5,8 @@ trait Foo extends Capability
 trait CaptureSet:
   type C >: CapSet <: CapSet^
 
-def capturePoly[C^](a: Foo^{C^}): Foo^{C^} = a
-def capturePoly2(c: CaptureSet)(a: Foo^{c.C^}): Foo^{c.C^} = a
+def capturePoly[C^](a: Foo^{C}): Foo^{C} = a
+def capturePoly2(c: CaptureSet)(a: Foo^{c.C}): Foo^{c.C} = a
 
 def test =
   val x: Foo^ = ???
@@ -15,8 +15,8 @@ def test =
   object X extends CaptureSet:
     type C = CapSet^{x}
 
-  val z1: Foo^{X.C^} = x
-  val z2: Foo^{X.C^} = y // error
+  val z1: Foo^{X.C} = x
+  val z2: Foo^{X.C} = y // error
 
   val z3: Foo^{x} = capturePoly(x)
   val z4: Foo^{x} = capturePoly(y) // error
diff --git a/tests/neg-custom-args/captures/capture-vars-subtyping.scala b/tests/neg-custom-args/captures/capture-vars-subtyping.scala
index 1986a0aa33fc..c0356bb0873f 100644
--- a/tests/neg-custom-args/captures/capture-vars-subtyping.scala
+++ b/tests/neg-custom-args/captures/capture-vars-subtyping.scala
@@ -3,32 +3,32 @@ import caps.*
 
 def test[C^] =
   val a: C = ???
-  val b: CapSet^{C^} = a
+  val b: CapSet^{C} = a
   val c: C = b
-  val d: CapSet^{C^, c} = a
+  val d: CapSet^{C, c} = a
 
 // TODO: make "CapSet-ness" of type variables somehow contagious?
 // Then we don't have to spell out the bounds explicitly...
 def testTrans[C^, D >: CapSet <: C, E >: CapSet <: D, F >: C <: CapSet^] =
   val d1: D = ???
-  val d2: CapSet^{D^} = d1
+  val d2: CapSet^{D} = d1
   val d3: D = d2
   val e1: E = ???
-  val e2: CapSet^{E^} = e1
+  val e2: CapSet^{E} = e1
   val e3: E = e2
   val d4: D = e1
   val c1: C = d1
   val c2: C = e1
   val f1: F = c1
-  val d_e_f1: CapSet^{D^,E^,F^} = d1
-  val d_e_f2: CapSet^{D^,E^,F^} = e1
-  val d_e_f3: CapSet^{D^,E^,F^} = f1
+  val d_e_f1: CapSet^{D,E,F} = d1
+  val d_e_f2: CapSet^{D,E,F} = e1
+  val d_e_f3: CapSet^{D,E,F} = f1
   val f2: F = d_e_f1
   val c3: C = d_e_f1 // error
   val c4: C = f1     // error
   val e4: E = f1     // error
   val e5: E = d1     // error
-  val c5: CapSet^{C^} = e1
+  val c5: CapSet^{C} = e1
 
 
 trait A[+T]
@@ -37,12 +37,12 @@ trait B[-C]
 
 def testCong[C^, D^] =
   val a: A[C] = ???
-  val b: A[CapSet^{C^}] = a
-  val c: A[CapSet^{D^}] = a // error
-  val d: A[CapSet^{C^,D^}] = a
+  val b: A[CapSet^{C}] = a
+  val c: A[CapSet^{D}] = a // error
+  val d: A[CapSet^{C,D}] = a
   val e: A[C] = d // error
   val f: B[C] = ???
-  val g: B[CapSet^{C^}] = f
+  val g: B[CapSet^{C}] = f
   val h: B[C] = g
-  val i: B[CapSet^{C^,D^}] = h // error
+  val i: B[CapSet^{C,D}] = h // error
   val j: B[C] = i
diff --git a/tests/neg-custom-args/captures/capture-vars-subtyping2.scala b/tests/neg-custom-args/captures/capture-vars-subtyping2.scala
index 205451ee41ed..0a3d776227cb 100644
--- a/tests/neg-custom-args/captures/capture-vars-subtyping2.scala
+++ b/tests/neg-custom-args/captures/capture-vars-subtyping2.scala
@@ -10,32 +10,32 @@ trait BoundsTest:
 
   def testTransMixed[A^,
                     B >: CapSet <: A,
-                    C >: CapSet <: CapSet^{B^},
+                    C >: CapSet <: CapSet^{B},
                     D >: CapSet <: C,
-                    E >: CapSet <: CapSet^{D^},
-                    F >: CapSet <: CapSet^{A^,b},
-                    X >: CapSet <: CapSet^{F^,D^},
-                    Y >: CapSet^{F^} <: CapSet^{F^,A^,b},
-                    Z >: CapSet^{b} <: CapSet^{b,Y^}] =
+                    E >: CapSet <: CapSet^{D},
+                    F >: CapSet <: CapSet^{A,b},
+                    X >: CapSet <: CapSet^{F,D},
+                    Y >: CapSet^{F} <: CapSet^{F,A,b},
+                    Z >: CapSet^{b} <: CapSet^{b,Y}] =
     val e: E = ???
-    val e2: CapSet^{E^} = e
+    val e2: CapSet^{E} = e
     val ed: D = e
-    val ed2: CapSet^{D^} = e
+    val ed2: CapSet^{D} = e
     val ec: C = e
-    val ec2: CapSet^{C^} = e
+    val ec2: CapSet^{C} = e
     val eb: B = e
-    val eb2: CapSet^{B^} = e
+    val eb2: CapSet^{B} = e
     val ea: A = e
-    val ea2: CapSet^{A^} = e
+    val ea2: CapSet^{A} = e
     val ex: X = e            // error
-    val ex2: CapSet^{X^} = e // error
+    val ex2: CapSet^{X} = e // error
     val f: F = ???
-    val f2: CapSet^{F^} = f
+    val f2: CapSet^{F} = f
     val y: Y = f
-    val y2: CapSet^{Y^} = f
+    val y2: CapSet^{Y} = f
     val cb: CapSet^{b} = ???
     val z: Z = cb
-    val z2: CapSet^{Z^} = cb
+    val z2: CapSet^{Z} = cb
 
   def callTransMixed =
     val x, y, z: Bar^ = ???
diff --git a/tests/neg-custom-args/captures/cc-poly-1.scala b/tests/neg-custom-args/captures/cc-poly-1.scala
index 580b124bc8f3..b205b9b25246 100644
--- a/tests/neg-custom-args/captures/cc-poly-1.scala
+++ b/tests/neg-custom-args/captures/cc-poly-1.scala
@@ -6,7 +6,7 @@ object Test:
   class C extends Capability
   class D
 
-  def f[X^](x: D^{X^}): D^{X^} = x
+  def f[X^](x: D^{X}): D^{X} = x
 
   def test(c1: C, c2: C) =
     f[Any](D()) // error
diff --git a/tests/neg-custom-args/captures/cc-poly-2.scala b/tests/neg-custom-args/captures/cc-poly-2.scala
index c9249ba59437..8fb590f4f769 100644
--- a/tests/neg-custom-args/captures/cc-poly-2.scala
+++ b/tests/neg-custom-args/captures/cc-poly-2.scala
@@ -6,7 +6,7 @@ object Test:
   class C extends Capability
   class D
 
-  def f[X^](x: D^{X^}): D^{X^} = x
+  def f[X^](x: D^{X}): D^{X} = x
 
   def test(c1: C, c2: C) =
     val d: D^ = D()
diff --git a/tests/neg-custom-args/captures/i21313.scala b/tests/neg-custom-args/captures/i21313.scala
index 01bedb10aefd..4b6d16c4da88 100644
--- a/tests/neg-custom-args/captures/i21313.scala
+++ b/tests/neg-custom-args/captures/i21313.scala
@@ -6,7 +6,7 @@ trait Async:
 def foo(x: Async) = x.await(???) // error
 
 trait Source[+T, Cap^]:
-  final def await(using ac: Async^{Cap^}) = ac.await[T, Cap](this) // Contains[Cap, ac] is assured because {ac} <: Cap.
+  final def await(using ac: Async^{Cap}) = ac.await[T, Cap](this) // Contains[Cap, ac] is assured because {ac} <: Cap.
 
 def test(using ac1: Async^, ac2: Async^, x: String) =
   val src1 = new Source[Int, CapSet^{ac1}] {}
diff --git a/tests/neg-custom-args/captures/i21347.scala b/tests/neg-custom-args/captures/i21347.scala
index 54fe859caedd..2e37511f053c 100644
--- a/tests/neg-custom-args/captures/i21347.scala
+++ b/tests/neg-custom-args/captures/i21347.scala
@@ -1,6 +1,6 @@
 import language.experimental.captureChecking
 
-def runOps[C^](ops: List[() ->{C^} Unit]): Unit =
+def runOps[C^](ops: List[() ->{C} Unit]): Unit =
   ops.foreach: op => // error
     op()
 
diff --git a/tests/neg-custom-args/captures/i21868.scala b/tests/neg-custom-args/captures/i21868.scala
index 876b68ac90a4..de6a9b64b78b 100644
--- a/tests/neg-custom-args/captures/i21868.scala
+++ b/tests/neg-custom-args/captures/i21868.scala
@@ -2,11 +2,11 @@ import caps.*
 
 trait AbstractWrong:
   type C <: CapSet
-  def f(): Unit^{C^} // error
+  def f(): Unit^{C} // error
 
 trait Abstract1:
   type C >: CapSet <: CapSet^
-  def f(): Unit^{C^}
+  def f(): Unit^{C}
 
 // class Abstract2:
 //   type C^
diff --git a/tests/neg-custom-args/captures/i21868b.scala b/tests/neg-custom-args/captures/i21868b.scala
index 70f4e9c9d59c..5cff4e3fac2e 100644
--- a/tests/neg-custom-args/captures/i21868b.scala
+++ b/tests/neg-custom-args/captures/i21868b.scala
@@ -7,7 +7,7 @@ class File
 
 trait Abstract:
   type C >: CapSet <: CapSet^
-  def f(file: File^{C^}): Unit
+  def f(file: File^{C}): Unit
 
 class Concrete1 extends Abstract:
   type C = CapSet
@@ -23,7 +23,7 @@ class Concrete3(io: IO^) extends Abstract:
 
 trait Abstract2(tracked val io: IO^):
   type C >: CapSet <: CapSet^{io}
-  def f(file: File^{C^}): Unit
+  def f(file: File^{C}): Unit
 
 class Concrete4(io: IO^) extends Abstract2(io):
   type C = CapSet
@@ -35,7 +35,7 @@ class Concrete5(io1: IO^, io2: IO^) extends Abstract2(io1):
 
 trait Abstract3[X^]:
   type C >: CapSet <: X
-  def f(file: File^{C^}): Unit
+  def f(file: File^{C}): Unit
 
 class Concrete6(io: IO^) extends Abstract3[CapSet^{io}]:
   type C = CapSet
diff --git a/tests/neg-custom-args/captures/i22005.scala b/tests/neg-custom-args/captures/i22005.scala
index a9dca999e42b..9cfdd621247d 100644
--- a/tests/neg-custom-args/captures/i22005.scala
+++ b/tests/neg-custom-args/captures/i22005.scala
@@ -4,5 +4,5 @@ class IO
 class File(io: IO^)
 
 class Handler[C^]:
-  def f(file: File^): File^{C^} = file // error
-  def g(file: File^{C^}): File^ = file // ok
+  def f(file: File^): File^{C} = file // error
+  def g(file: File^{C}): File^ = file // ok
diff --git a/tests/neg-custom-args/captures/polyCaptures.check b/tests/neg-custom-args/captures/polyCaptures.check
index 8173828b7bc8..08ebaf1c63ee 100644
--- a/tests/neg-custom-args/captures/polyCaptures.check
+++ b/tests/neg-custom-args/captures/polyCaptures.check
@@ -1,8 +1,8 @@
 -- Error: tests/neg-custom-args/captures/polyCaptures.scala:4:22 -------------------------------------------------------
-4 |val runOpsCheck: [C^] -> (ops: List[() ->{C^} Unit]) ->{C^} Unit = runOps  // error
+4 |val runOpsCheck: [C^] -> (ops: List[() ->{C} Unit]) ->{C} Unit = runOps  // error
   |                      ^
   |          Implementation restriction: polymorphic function types cannot wrap function types that have capture sets
 -- Error: tests/neg-custom-args/captures/polyCaptures.scala:5:23 -------------------------------------------------------
-5 |val runOpsCheck2: [C^] => (ops: List[() ->{C^} Unit]) ->{C^} Unit = runOps // error
+5 |val runOpsCheck2: [C^] => (ops: List[() ->{C} Unit]) ->{C} Unit = runOps // error
   |                       ^
   |          Implementation restriction: polymorphic function types cannot wrap function types that have capture sets
diff --git a/tests/neg-custom-args/captures/polyCaptures.scala b/tests/neg-custom-args/captures/polyCaptures.scala
index 776af95e5dcf..eb8e50f0b997 100644
--- a/tests/neg-custom-args/captures/polyCaptures.scala
+++ b/tests/neg-custom-args/captures/polyCaptures.scala
@@ -1,7 +1,7 @@
 class Box[X](val elem: X)
 
-val runOps = [C^] => (b: Box[() ->{C^} Unit]) => b.elem()
-val runOpsCheck: [C^] -> (ops: List[() ->{C^} Unit]) ->{C^} Unit = runOps  // error
-val runOpsCheck2: [C^] => (ops: List[() ->{C^} Unit]) ->{C^} Unit = runOps // error
+val runOps = [C^] => (b: Box[() ->{C} Unit]) => b.elem()
+val runOpsCheck: [C^] -> (ops: List[() ->{C} Unit]) ->{C} Unit = runOps  // error
+val runOpsCheck2: [C^] => (ops: List[() ->{C} Unit]) ->{C} Unit = runOps // error
 
 
diff --git a/tests/neg-custom-args/captures/use-capset.check b/tests/neg-custom-args/captures/use-capset.check
index 74afaa05890f..8ae4b34e9902 100644
--- a/tests/neg-custom-args/captures/use-capset.check
+++ b/tests/neg-custom-args/captures/use-capset.check
@@ -1,8 +1,8 @@
--- Error: tests/neg-custom-args/captures/use-capset.scala:5:50 ---------------------------------------------------------
-5 |private def g[C^] = (xs: List[Object^{C^}]) => xs.head // error
-  |                                               ^^^^^^^
-  |                                               Capture set parameter C leaks into capture scope of method g.
-  |                                               To allow this, the type C should be declared with a @use annotation
+-- Error: tests/neg-custom-args/captures/use-capset.scala:5:49 ---------------------------------------------------------
+5 |private def g[C^] = (xs: List[Object^{C}]) => xs.head // error
+  |                                              ^^^^^^^
+  |                                              Capture set parameter C leaks into capture scope of method g.
+  |                                              To allow this, the type C should be declared with a @use annotation
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/use-capset.scala:11:22 -----------------------------------
 11 |  val _: () -> Unit = h // error: should be ->{io}
    |                      ^
diff --git a/tests/neg-custom-args/captures/use-capset.scala b/tests/neg-custom-args/captures/use-capset.scala
index 74288d616396..4f2c239247e6 100644
--- a/tests/neg-custom-args/captures/use-capset.scala
+++ b/tests/neg-custom-args/captures/use-capset.scala
@@ -1,10 +1,10 @@
 import caps.{use, CapSet}
 
-def f[C^](@use xs: List[Object^{C^}]): Unit = ???
+def f[C^](@use xs: List[Object^{C}]): Unit = ???
 
-private def g[C^] = (xs: List[Object^{C^}]) => xs.head // error
+private def g[C^] = (xs: List[Object^{C}]) => xs.head // error
 
-private def g2[@use C^] = (xs: List[Object^{C^}]) => xs.head // ok
+private def g2[@use C^] = (xs: List[Object^{C}]) => xs.head // ok
 
 def test(io: Object^)(@use xs: List[Object^{io}]): Unit =
   val h = () => f(xs)
diff --git a/tests/pending/cap-paramlists8.scala b/tests/pending/cap-paramlists8.scala
new file mode 100644
index 000000000000..5151629283f6
--- /dev/null
+++ b/tests/pending/cap-paramlists8.scala
@@ -0,0 +1,10 @@
+import language.experimental.captureChecking
+
+trait Ctx[T]
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+  val baz3 = (i: Int) => [cap C, cap D <: {C}, cap E <: {C,x}] => () => [cap F >: {x,y} <: {C,E} : Ctx] => (x: Int) => 1
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/cap-paramlists.scala b/tests/pos-custom-args/captures/cap-paramlists.scala
new file mode 100644
index 000000000000..c81bcd5b5440
--- /dev/null
+++ b/tests/pos-custom-args/captures/cap-paramlists.scala
@@ -0,0 +1,23 @@
+import language.experimental.captureChecking
+
+trait Ctx[T]
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+  def foo[cap A >: {y} <: {x},
+          cap B,
+          cap C <: {x},
+          cap D : Ctx,
+          cap E <: {C},
+          cap F <: {C},
+          cap G <: {x, y},
+          cap H >: {x} <: {x,y} : Ctx, T, U]()[cap I <: {y, G, H},
+                                               cap J <: {O.z},
+                                               cap K <: {x, O.z},
+                                               cap L <: {x, y, O.z},
+                                               cap M >: {x, y, O.z} <: {C} : Ctx,
+                                               cap N >: {x} <: {x},
+                                               cap O >: {O.z} <: {O.z}] = ???
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/cap-paramlists2.scala b/tests/pos-custom-args/captures/cap-paramlists2.scala
new file mode 100644
index 000000000000..284fa9c6b3d9
--- /dev/null
+++ b/tests/pos-custom-args/captures/cap-paramlists2.scala
@@ -0,0 +1,6 @@
+import language.experimental.captureChecking
+
+trait Bar:
+  cap type C
+
+def useFoo[cap D](x: Bar { cap type C = {D} } ): Any^{x.C} = ???
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/cap-paramlists3.scala b/tests/pos-custom-args/captures/cap-paramlists3.scala
new file mode 100644
index 000000000000..ebd3bc171a57
--- /dev/null
+++ b/tests/pos-custom-args/captures/cap-paramlists3.scala
@@ -0,0 +1,10 @@
+import language.experimental.captureChecking
+
+trait Ctx[T]
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+  val bar = [cap C, cap D <: {C}, cap E <: {C,x}, cap F >: {x,y} <: {C,E}] => (x: Int) => 1
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/cap-paramlists4.scala b/tests/pos-custom-args/captures/cap-paramlists4.scala
new file mode 100644
index 000000000000..16ef9b2ee935
--- /dev/null
+++ b/tests/pos-custom-args/captures/cap-paramlists4.scala
@@ -0,0 +1,6 @@
+import language.experimental.captureChecking
+
+trait Foo[cap U, cap V, cap W]:
+  cap type C = {caps.cap}
+  cap type D = {caps.cap}
+  cap type E >: {V,W} <: {U}
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/cap-paramlists5.scala b/tests/pos-custom-args/captures/cap-paramlists5.scala
new file mode 100644
index 000000000000..d2599787d5a2
--- /dev/null
+++ b/tests/pos-custom-args/captures/cap-paramlists5.scala
@@ -0,0 +1,9 @@
+import language.experimental.captureChecking
+import language.experimental.namedTypeArguments
+
+def test2 =
+  val x: Any^ = ???
+  def foo[cap A, cap B >: {A}, T](x: Int) = 1
+  foo[{x}, {x}, Int](0)
+ // foo[cap A = {x}, cap B = {x}](0)
+ // foo[cap A = {x}](0)
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/cap-paramlists6.scala b/tests/pos-custom-args/captures/cap-paramlists6.scala
new file mode 100644
index 000000000000..f230890e8374
--- /dev/null
+++ b/tests/pos-custom-args/captures/cap-paramlists6.scala
@@ -0,0 +1,10 @@
+import language.experimental.captureChecking
+
+trait Ctx[T]
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+  val baz  = () => [cap C, cap D <: {C}, cap E <: {C,x}, cap F >: {x,y} <: {C,E} : Ctx] => (x: Int) => 1
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/cap-paramlists7.scala b/tests/pos-custom-args/captures/cap-paramlists7.scala
new file mode 100644
index 000000000000..9a46787e7e34
--- /dev/null
+++ b/tests/pos-custom-args/captures/cap-paramlists7.scala
@@ -0,0 +1,10 @@
+import language.experimental.captureChecking
+
+trait Ctx[T]
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+  val baz2 = (i: Int) => [cap C, cap D <: {C}, cap E <: {C,x}, cap F >: {x,y} <: {C,E} : Ctx] => (x: Int) => 1
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/capset-members.scala b/tests/pos-custom-args/captures/capset-members.scala
new file mode 100644
index 000000000000..eed7f4a2fa15
--- /dev/null
+++ b/tests/pos-custom-args/captures/capset-members.scala
@@ -0,0 +1,25 @@
+import language.experimental.captureChecking
+
+trait Ctx[T]
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+  trait CaptureSet:
+    cap type A >: {y} <: {x}
+    cap type B = {x}
+    cap type C <: {x}
+    cap type D : Ctx
+    cap type E <: {C}
+    cap type F <: {C}
+    cap type G <: {x, y}
+    cap type H >: {x} <: {x,y} : Ctx
+    cap type I = {y, G, H}
+    cap type J = {O.z}
+    cap type K = {x, O.z}
+    cap type L <: {x, y, O.z}
+    cap type M >: {x, y, O.z} <: {C}
+    cap type N >: {x} <: {x}
+    cap type O >: {O.z} <: {O.z}
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/cc-poly-1.scala b/tests/pos-custom-args/captures/cc-poly-1.scala
index ed32d94f7a99..e423d94d4000 100644
--- a/tests/pos-custom-args/captures/cc-poly-1.scala
+++ b/tests/pos-custom-args/captures/cc-poly-1.scala
@@ -7,9 +7,9 @@ import caps.{CapSet, Capability}
   class C extends Capability
   class D
 
-  def f[X^](x: D^{X^}): D^{X^} = x
-  def g[X^](x: D^{X^}, y: D^{X^}): D^{X^} = x
-  def h[X^](): D^{X^} = ???
+  def f[X^](x: D^{X}): D^{X} = x
+  def g[X^](x: D^{X}, y: D^{X}): D^{X} = x
+  def h[X^](): D^{X} = ???
 
   def test(c1: C, c2: C) =
     val d: D^{c1, c2} = D()
diff --git a/tests/pos-custom-args/captures/cc-poly-source-capability.scala b/tests/pos-custom-args/captures/cc-poly-source-capability.scala
index 6f6bdd91d20a..95743a44e272 100644
--- a/tests/pos-custom-args/captures/cc-poly-source-capability.scala
+++ b/tests/pos-custom-args/captures/cc-poly-source-capability.scala
@@ -12,11 +12,11 @@ import caps.use
   class Listener
 
   class Source[X^]:
-    private var listeners: Set[Listener^{X^}] = Set.empty
-    def register(x: Listener^{X^}): Unit =
+    private var listeners: Set[Listener^{X}] = Set.empty
+    def register(x: Listener^{X}): Unit =
       listeners += x
 
-    def allListeners: Set[Listener^{X^}] = listeners
+    def allListeners: Set[Listener^{X}] = listeners
 
   def test1(async1: Async, @use others: List[Async]) =
     val src = Source[CapSet^{async1, others*}]
diff --git a/tests/pos-custom-args/captures/cc-poly-source.scala b/tests/pos-custom-args/captures/cc-poly-source.scala
index 2de5c6d67340..ed80155a1d73 100644
--- a/tests/pos-custom-args/captures/cc-poly-source.scala
+++ b/tests/pos-custom-args/captures/cc-poly-source.scala
@@ -10,11 +10,11 @@ import caps.use
   class Listener
 
   class Source[X^]:
-    private var listeners: Set[Listener^{X^}] = Set.empty
-    def register(x: Listener^{X^}): Unit =
+    private var listeners: Set[Listener^{X}] = Set.empty
+    def register(x: Listener^{X}): Unit =
       listeners += x
 
-    def allListeners: Set[Listener^{X^}] = listeners
+    def allListeners: Set[Listener^{X}] = listeners
 
   def test1(lbl1: Label^, lbl2: Label^) =
     val src = Source[CapSet^{lbl1, lbl2}]
diff --git a/tests/pos-custom-args/captures/cc-poly-varargs.scala b/tests/pos-custom-args/captures/cc-poly-varargs.scala
index 8bd0dc89bc7a..13e4b276df5a 100644
--- a/tests/pos-custom-args/captures/cc-poly-varargs.scala
+++ b/tests/pos-custom-args/captures/cc-poly-varargs.scala
@@ -1,13 +1,13 @@
 abstract class Source[+T, Cap^]
 
 extension[T, Cap^](src: Source[T, Cap]^)
-  def transformValuesWith[U](f: (T -> U)^{Cap^}): Source[U, Cap]^{src, f} = ???
+  def transformValuesWith[U](f: (T -> U)^{Cap}): Source[U, Cap]^{src, f} = ???
 
-def race[T, Cap^](sources: Source[T, Cap]^{Cap^}*): Source[T, Cap]^{Cap^} = ???
+def race[T, Cap^](sources: Source[T, Cap]^{Cap}*): Source[T, Cap]^{Cap} = ???
 
 def either[T1, T2, Cap^](
-    src1: Source[T1, Cap]^{Cap^},
-    src2: Source[T2, Cap]^{Cap^}): Source[Either[T1, T2], Cap]^{Cap^} =
+    src1: Source[T1, Cap]^{Cap},
+    src2: Source[T2, Cap]^{Cap}): Source[Either[T1, T2], Cap]^{Cap} =
   val left = src1.transformValuesWith(Left(_))
   val right = src2.transformValuesWith(Right(_))
   race(left, right)
diff --git a/tests/pos-custom-args/captures/gears-problem-poly.scala b/tests/pos-custom-args/captures/gears-problem-poly.scala
index fdbcf37a35a6..f7632bce4124 100644
--- a/tests/pos-custom-args/captures/gears-problem-poly.scala
+++ b/tests/pos-custom-args/captures/gears-problem-poly.scala
@@ -7,8 +7,8 @@ trait Future[+T]:
 trait Channel[+T]:
   def read(): Ok[T]
 
-class Collector[T, C^](val futures: Seq[Future[T]^{C^}]):
-  val results: Channel[Future[T]^{C^}] = ???
+class Collector[T, C^](val futures: Seq[Future[T]^{C}]):
+  val results: Channel[Future[T]^{C}] = ???
 end Collector
 
 class Result[+T, +E]:
@@ -17,10 +17,10 @@ class Result[+T, +E]:
 case class Err[+E](e: E) extends Result[Nothing, E]
 case class Ok[+T](x: T) extends Result[T, Nothing]
 
-extension [T, C^](@use fs: Seq[Future[T]^{C^}])
+extension [T, C^](@use fs: Seq[Future[T]^{C}])
   def awaitAllPoly =
     val collector = Collector(fs)
-    val fut: Future[T]^{C^} = collector.results.read().get
+    val fut: Future[T]^{C} = collector.results.read().get
 
 extension [T](@use fs: Seq[Future[T]^])
   def awaitAll = fs.awaitAllPoly
diff --git a/tests/pos-custom-args/captures/i21313.scala b/tests/pos-custom-args/captures/i21313.scala
index b388b6487cb5..e55bf9c7ce62 100644
--- a/tests/pos-custom-args/captures/i21313.scala
+++ b/tests/pos-custom-args/captures/i21313.scala
@@ -3,17 +3,17 @@ import caps.CapSet
 trait Async:
   def await[T, Cap^](using caps.Contains[Cap, this.type])(src: Source[T, Cap]^): T =
     val x: Async^{this} = ???
-    val y: Async^{Cap^} = x
+    val y: Async^{Cap} = x
     val ac: Async^ = ???
     def f(using caps.Contains[Cap, ac.type]) =
       val x2: Async^{this} = ???
-      val y2: Async^{Cap^} = x2
+      val y2: Async^{Cap} = x2
       val x3: Async^{ac} = ???
-      val y3: Async^{Cap^} = x3
+      val y3: Async^{Cap} = x3
     ???
 
 trait Source[+T, Cap^]:
-  final def await(using ac: Async^{Cap^}) = ac.await[T, Cap](this) // Contains[Cap, ac] is assured because {ac} <: Cap.
+  final def await(using ac: Async^{Cap}) = ac.await[T, Cap](this) // Contains[Cap, ac] is assured because {ac} <: Cap.
 
 def test(using ac1: Async^, ac2: Async^, x: String) =
   val src1 = new Source[Int, CapSet^{ac1}] {}
diff --git a/tests/pos-custom-args/captures/i21347.scala b/tests/pos-custom-args/captures/i21347.scala
index a965b7e4f26b..9dbb8b154cfb 100644
--- a/tests/pos-custom-args/captures/i21347.scala
+++ b/tests/pos-custom-args/captures/i21347.scala
@@ -4,7 +4,7 @@ import language.experimental.captureChecking
 
 class Box[Cap^] {}
 
-def run[Cap^](f: Box[Cap]^{Cap^} => Unit): Box[Cap]^{Cap^} = ???
+def run[Cap^](f: Box[Cap]^{Cap} => Unit): Box[Cap]^{Cap} = ???
 
 def main() =
   val b = run(_ => ())
diff --git a/tests/pos-custom-args/captures/i21507.scala b/tests/pos-custom-args/captures/i21507.scala
index bb80dafb3b45..4267795d3a41 100644
--- a/tests/pos-custom-args/captures/i21507.scala
+++ b/tests/pos-custom-args/captures/i21507.scala
@@ -1,10 +1,10 @@
 import language.experimental.captureChecking
 
 trait Box[Cap^]:
-  def store(f: (() -> Unit)^{Cap^}): Unit
+  def store(f: (() -> Unit)^{Cap}): Unit
 
-def run[Cap^](f: Box[Cap]^{Cap^} => Unit): Box[Cap]^{Cap^} =
+def run[Cap^](f: Box[Cap]^{Cap} => Unit): Box[Cap]^{Cap} =
   new Box[Cap]:
-    private var item: () ->{Cap^} Unit = () => ()
-    def store(f: () ->{Cap^} Unit): Unit =
+    private var item: () ->{Cap} Unit = () => ()
+    def store(f: () ->{Cap} Unit): Unit =
       item = f  // was error, now ok
diff --git a/tests/pos-custom-args/captures/setup/a_1.scala b/tests/pos-custom-args/captures/setup/a_1.scala
index 21afde8be3ea..3a6ec7ffa773 100644
--- a/tests/pos-custom-args/captures/setup/a_1.scala
+++ b/tests/pos-custom-args/captures/setup/a_1.scala
@@ -3,4 +3,4 @@ import language.experimental.captureChecking
 import scala.caps.CapSet
 
 trait A:
-  def f[C^](x: AnyRef^{C^}): Unit
+  def f[C^](x: AnyRef^{C}): Unit
diff --git a/tests/pos-custom-args/captures/setup/b_1.scala b/tests/pos-custom-args/captures/setup/b_1.scala
index d5ba925970ba..70c72723c84c 100644
--- a/tests/pos-custom-args/captures/setup/b_1.scala
+++ b/tests/pos-custom-args/captures/setup/b_1.scala
@@ -2,4 +2,4 @@ import language.experimental.captureChecking
 import scala.caps.CapSet
 
 class B extends A:
-  def f[C^](x: AnyRef^{C^}): Unit = ???
+  def f[C^](x: AnyRef^{C}): Unit = ???
diff --git a/tests/pos-custom-args/captures/setup/b_2.scala b/tests/pos-custom-args/captures/setup/b_2.scala
index d5ba925970ba..70c72723c84c 100644
--- a/tests/pos-custom-args/captures/setup/b_2.scala
+++ b/tests/pos-custom-args/captures/setup/b_2.scala
@@ -2,4 +2,4 @@ import language.experimental.captureChecking
 import scala.caps.CapSet
 
 class B extends A:
-  def f[C^](x: AnyRef^{C^}): Unit = ???
+  def f[C^](x: AnyRef^{C}): Unit = ???