diff --git a/subathon/component.py b/subathon/component.py
index 002c3f5..5dbed6d 100644
--- a/subathon/component.py
+++ b/subathon/component.py
@@ -1,3 +1,4 @@
+import re
 from collections import defaultdict
 from datetime import datetime, timedelta
 from typing import Optional
@@ -17,6 +18,36 @@ from .channel import SubathonPayload, prepare_subathon, TimerChannel
 
 
 class SubathonComponent(cmds.Component):
+    """
+    !subathon 
+    !subathon setup <initial_hours> <t1score> <t2score> <t3score> <bitscore> <timescore> [cap]
+    !subathon stop 
+
+    !subathon link 
+    !subathon pause 
+    !subathon resume
+
+    !subathon adjust <amount> [@user]
+
+    !subathon config 
+    !subathon config name [new name]
+    !subathon config cap [new cap]
+    !subathon config scores [<t1score> <t2score> <t3score> <bitscore>]
+    !subathon config timescore [new score]
+
+    !subathon lb
+
+    !goals 
+    !goals remaining 
+    !goals add <points> <description>
+    !goals remove <points>
+    
+
+    Command:
+    Permissions:
+    Description:
+    Examples:
+    """
     # TODO: Add explicit dependencies and version checks
     # for profile and event tracker modules
 
@@ -60,6 +91,36 @@ class SubathonComponent(cmds.Component):
                 await goal.update(notified=True)
 
     # ----- Event Handlers -----
+    # Blerp handler
+    @cmds.Component.listener()
+    async def event_message(self, message: twitchio.ChatMessage):
+        if message.chatter.id not in ('253326823', '1361913054'):
+            return
+        if 'bits' not in message.text:
+            return
+        community = await self.bot.profiles.fetch_community(message.broadcaster)
+        cid = community.communityid
+        if (active := await self.get_active_subathon(cid)) is not None and not await active.check_finished():
+            # Extract count and user
+            match = re.match(r"(?P<name>\w+) used (?P<amount>\d+)", message.text)
+            if not match:
+                match = re.match(r"!For (?P<amount>\d+) bits, (?P<name>\w+)", message.text)
+            if match:
+                amount = int(match['amount'])
+                name = match['name']
+                # This is for giving the contribution to the calling user
+                # user = await self.bot.fetch_user(login=name.lower())
+                user = await message.chatter.user()
+                profile = await self.bot.profiles.fetch_profile(user)
+                pid = profile.profileid
+
+                score = amount * active.subathondata.bit_score
+                contrib = await active.add_contribution(pid, score, None)
+                await self.dispatch_update(active)
+                logger.info(f"Blerp contribution: {contrib!r} from {message!r}")
+            else:
+                logger.warning(f"Unknown blerp bit message: {message!r}")
+
     @cmds.Component.listener()
     async def event_safe_bits_use(self, payload):
         event_row, detail_row, bits_payload = payload
@@ -273,9 +334,10 @@ class SubathonComponent(cmds.Component):
             await ctx.reply("No active subathon running!")
 
     # subathon start 
+    # TODO: Usage line on command error
     @group_subathon.command(name='setup', alias='start')
     @cmds.is_broadcaster()
-    async def cmd_setup(self, ctx: cmds.Context, name: str, initial_hours: float, sub1: float, sub2: float, sub3: float, bit: float, timescore: int, timecap: Optional[int]=None):
+    async def cmd_setup(self, ctx: cmds.Context, initial_hours: float, sub1: float, sub2: float, sub3: float, bit: float, timescore: int, timecap: Optional[int]=None):
         """
         Creates a new subathon.
         USAGE: {prefix}subathon setup <initial_hours> <sub1_points> <sub2_points> <sub3_points> <bit_points> <timepoints> [timecap]
@@ -298,7 +360,6 @@ class SubathonComponent(cmds.Component):
         
         subdata = await Subathon.create(
             communityid=cid,
-            name=name,
             initial_time=initial_time,
             sub1_score=sub1,
             sub2_score=sub2,
@@ -309,7 +370,12 @@ class SubathonComponent(cmds.Component):
         )
         base_timer_url = self.bot.config.subathon['timer_url']
         timer_link = f"{base_timer_url}?community={cid}"
-        await ctx.reply(f"Setup your {name}! Use !subathon resume to get the timer running. Your timer link: {timer_link}")
+        await ctx.reply(
+            f"Setup your subathon! "
+            f"Use {ctx.prefix}subathon resume to get the timer running. "
+            f"Use {ctx.prefix}subathon config to see and set options, including the name. "
+            f"Your timer link for OBS: {timer_link}"
+        )
         active = ActiveSubathon(subdata, None)
         await self.dispatch_update(active)
 
@@ -451,7 +517,7 @@ class SubathonComponent(cmds.Component):
                     cap = active.subathondata.timecap
                     if cap:
                         hours = cap / 3600
-                        await ctx.reply(f"The timer cap is currently {hours} hours")
+                    await ctx.reply(f"The timer cap is currently {hours} hours")
             elif option.lower() == 'name':
                 if value:
                     await active.subathondata.update(name=value)
@@ -461,10 +527,219 @@ class SubathonComponent(cmds.Component):
                     name = active.subathondata.name 
                     await ctx.reply(f"This subathon is called \"{name}\"")
             else:
+                # TODO: Add score and timescore config, probably move this to subcommands
                 await ctx.reply(
                     f"Unknown option {option}! Configurable options: 'name', 'cap'"
                 )
 
+    """
+    !subathon config
+        name="Birthday Subathon" ; cap=10 (hours) ; scores=5 10 20 0.1 (t1, t2, t3, and bit points) ; timescore=10 (seconds per point); Use !subathon config <option> [value] to see or set individual options
+    !subathon config name [value]
+    !subathon config cap [value]
+    !subathon config scores [value]
+    !subathon config timescore [value]
+
+    !subathon config name
+        Name of the subathon, used whenever the subathon is mentioned.
+        Accepts any string. Example: !subathon config name Birthday Subathon
+    !subathon config cap 
+        Duration cap of the subathon, in hours, including the initial time.
+        The subathon may still be contributed to after this time, but contributions
+        will not raise the timer.
+        Accepts an integer, with 0 to unset. Example: !subathon config cap 10
+    !subathon config scores
+        The number of points each type of contribution (t1 sub, t2 sub, t3 sub, 1 bit)
+        will add to the subathon. Not retroactive. Accepts four floats.
+        Example: !subathon config scores 5 10 20 0.1
+    !subathon config timescore 
+        The number of seconds each contributed point adds to the timer.
+        WARNING: This setting is retroactive and should generally not be changed.
+        Accepts an integer. Example: !subathon config timecap 10
+    """
+    @group_subathon.group(name='config', aliases=('option',), invoke_fallback=True)
+    @cmds.is_moderator()
+    async def subathon_config_grp(self, ctx: Context, *, args: Optional[str] = None):
+        community = await self.bot.profiles.fetch_community(ctx.broadcaster)
+        cid = community.communityid
+        if (active := await self.get_active_subathon(cid)) is None:
+            await ctx.reply("No active subathon to configure!")
+            return
+        if args:
+            await ctx.reply(
+                f"USAGE: {ctx.prefix}subathon config [option [value]]\n"
+                f"Use '{ctx.prefix}subathon config' to see available options and current values."
+            )
+            return
+
+        parts = []
+
+        sdata = active.subathondata
+
+        # name
+        parts.append(
+            f"name=\"{sdata.name}\""
+        )
+
+        # timecamp
+        cap = sdata.timecap or 0
+        caph = cap / 3600
+        parts.append(
+            f"cap=\"{caph}\" (hours, 0 means no cap)"
+        )
+
+        # scores
+        scores = map(float, (sdata.sub1_score, sdata.sub2_score, sdata.sub3_score, sdata.bit_score))
+        scorestr = ' '.join(map(str, scores))
+        parts.append(
+            f"scores={scorestr} (t1, t2, t3, and 1 bit point scores)"
+        )
+
+        # timescore
+        parts.append(
+            f"timescore={sdata.score_time} (seconds per point)"
+        )
+
+        # Combine
+        partstr = ' ; '.join(parts)
+        await ctx.reply(
+            f"{partstr} ; Use {ctx.prefix}subathon config <option> [value] to see or set each option!"
+        )
+
+    @subathon_config_grp.command(name='name')
+    @cmds.is_moderator()
+    async def subathon_config_name_cmd(self, ctx: Context, *, args: Optional[str] = None):
+        community = await self.bot.profiles.fetch_community(ctx.broadcaster)
+        cid = community.communityid
+        if (active := await self.get_active_subathon(cid)) is None:
+            await ctx.reply("No active subathon to configure!")
+            return
+
+        if args:
+            # Setting path
+            await active.subathondata.update(name=args)
+            await self.dispatch_update(active)
+            await ctx.reply(f"Updated the subathon name to \"{args}\"")
+        else:
+            # Display path
+            name = active.subathondata.name
+            await ctx.reply(
+                "Name of the subathon, used whenever the subathon is mentioned. "
+                "Accepts any string. "
+                f"Currently: \"{name}\" "
+                f"Example: {ctx.prefix}subathon config name Birthday Subathon"
+            )
+
+    @subathon_config_grp.command(name='cap')
+    @cmds.is_moderator()
+    async def subathon_config_cap_cmd(self, ctx: Context, *, args: Optional[str] = None):
+        community = await self.bot.profiles.fetch_community(ctx.broadcaster)
+        cid = community.communityid
+        if (active := await self.get_active_subathon(cid)) is None:
+            await ctx.reply("No active subathon to configure!")
+            return
+
+        if args:
+            # Setting path
+            if args.lower() in ('none',):
+                args = '0'
+
+            if not args.isdigit():
+                await ctx.reply("Provided timer cap must be an integer number of hours!")
+                return 
+
+            new_cap = int(args)
+            if new_cap <= 0:
+                # Unset the cap 
+                await active.subathondata.update(timecap=None)
+                await self.dispatch_update(active)
+                await ctx.reply("The timer cap has been removed! To infinity and beyond!")
+            else:
+                # Set the cap
+                await active.subathondata.update(timecap=int(new_cap * 3600))
+                await self.dispatch_update(active)
+                await ctx.reply(f"The subathon timer has been capped to {new_cap} hours.")
+        else:
+            # Display path
+            current_cap = active.subathondata.timecap or 0
+            caph = current_cap / 3600
+            await ctx.reply(
+                "Duration cap for this subathon, in hours, including the initial time. "
+                "Contributions given after the cap has been reached will be accepted, "
+                "but will not raise the timer. "
+                "Accepts an integer, with 0 meaning no cap. "
+                f"Currently: {caph} hours. "
+                f"Example: {ctx.prefix}subathon config cap 24"
+            )
+
+    @subathon_config_grp.command(name='scores')
+    @cmds.is_moderator()
+    async def subathon_config_scores_cmd(self, ctx: Context, *, args: Optional[str] = None):
+        community = await self.bot.profiles.fetch_community(ctx.broadcaster)
+        cid = community.communityid
+        if (active := await self.get_active_subathon(cid)) is None:
+            await ctx.reply("No active subathon to configure!")
+            return
+
+        if args:
+            # Setting path
+            # Validate
+            splits = args.split()
+            if not len(splits) == 4 and all(split.isdigit() for split in splits):
+                await ctx.reply(
+                    f"USAGE: {ctx.prefix}subathon config socres [<t1score> <t2score> <t3score> <bitscore>]"
+                )
+                return
+            t1score, t2score, t3score, bitscore = map(int, splits)
+            await active.subathondata.update(
+                sub1_score=t1score,
+                sub2_score=t2score,
+                sub3_score=t3score,
+                bit_score=bitscore,
+            )
+            await self.dispatch_update(active)
+            await ctx.reply("Successfully updated subathon score table.")
+        else:
+            # Display path 
+            sdata = active.subathondata
+            scores = map(float, (sdata.sub1_score, sdata.sub2_score, sdata.sub3_score, sdata.bit_score))
+            scorestr = ' '.join(map(str, scores))
+
+            await ctx.reply(
+                "The number of points each type of contribution (t1 sub, t2 sub, t3 sub, and 1 bit) "
+                "will add to the subathon. Not retroactive. "
+                "Accepts four floats. "
+                f"Currently: {scorestr} "
+                f"Example: {ctx.prefix}subathon config scores 5 10 20 0.1"
+            )
+
+    @subathon_config_grp.command(name='timescore')
+    @cmds.is_moderator()
+    async def subathon_config_timescore_cmd(self, ctx: Context, *, args: Optional[str] = None):
+        community = await self.bot.profiles.fetch_community(ctx.broadcaster)
+        cid = community.communityid
+        if (active := await self.get_active_subathon(cid)) is None:
+            await ctx.reply("No active subathon to configure!")
+            return
+
+        if args:
+            # Setting path
+            if not args.isdigit():
+                await ctx.reply("Time score (seconds per point) must be an integer.")
+                return 
+            await active.subathondata.update(score_time=int(args))
+            await self.dispatch_update(active)
+            await ctx.reply("Subathon time score updated (NOTE: This is retroactive).")
+        else:
+            # Display path
+            await ctx.reply(
+                "The number of seconds each contributed point adds to the timer. "
+                "WARNING: This setting is retroactive and should generally not be used. "
+                "Accepts an integer. "
+                f"Currently: {active.subathondata.score_time} (seconds per point) "
+                f"Example: {ctx.prefix}subathon config timescore 10"
+            )
+
     @group_subathon.command(name='leaderboard', aliases=('top', 'lb',))
     async def cmd_subathon_lb(self, ctx: Context):
         """
@@ -559,7 +834,7 @@ class SubathonComponent(cmds.Component):
                 text = ', '.join(goalstrs)
                 await ctx.reply(f"{active.name} Goals Remaining -- {text}")
             elif goals:
-                await ctx.reply(f"All goals completed, congratulations!")
+                await ctx.reply("All goals completed, congratulations!")
             else:
                 await ctx.reply("No goals have been configured!")
         else: