diff --git a/app.go b/app.go
index 6a4db4f..5d839c2 100644
--- a/app.go
+++ b/app.go
@@ -9,6 +9,7 @@ import (
 	"github.com/energye/systray"
 	"github.com/go-co-op/gocron/v2"
 	"github.com/google/uuid"
+	"github.com/thoas/go-funk"
 	"github.com/wailsapp/wails/v2/pkg/runtime"
 )
 
@@ -20,6 +21,99 @@ type App struct {
 	settings  *Settings
 }
 
+type Settings struct {
+	Config Config `json:"config"`
+}
+
+type B2Options struct {
+	B2AccountId  string `json:"b2_account_id"`
+	B2AccountKey string `json:"b2_account_key"`
+}
+
+type AzureOptions struct {
+	AzureAccountName    string `json:"azure_account_name"`
+	AzureAccountKey     string `json:"azure_account_key"`
+	AzureAccountSas     string `json:"azure_account_sas"`
+	AzureEndpointSuffix string `json:"azure_endpoint_suffix"`
+}
+
+type Options struct {
+	B2Options
+	AzureOptions
+}
+
+type RepositoryType int32
+
+const (
+	LOCAL  RepositoryType = iota
+	B2     RepositoryType = iota
+	AWS    RepositoryType = iota
+	AZURE  RepositoryType = iota
+	GOOGLE RepositoryType = iota
+)
+
+type Snapshot struct {
+	Id             string    `json:"id"`
+	Time           time.Time `json:"time"`
+	Paths          []string  `json:"paths"`
+	Hostname       string    `json:"hostname"`
+	Username       string    `json:"username"`
+	UID            uint32    `json:"uid"`
+	GID            uint32    `json:"gid"`
+	ShortId        string    `json:"short_id"`
+	Tags           []string  `json:"tags"`
+	ProgramVersion string    `json:"program_version"`
+}
+
+type FileDescriptor struct {
+	Name  string `json:"name"`
+	Type  string `json:"type"`
+	Path  string `json:"path"`
+	Size  uint32 `json:"size"`
+	Mtime string `json:"mtime"`
+}
+
+type Mount struct {
+	RepositoryId string `json:"repository_id"`
+	Path         string `json:"path"`
+}
+
+type Repository struct {
+	Id          string         `json:"id"`
+	Name        string         `json:"name"`
+	Type        RepositoryType `json:"type"`
+	PruneParams [][]string     `json:"prune_params"`
+	Path        string         `json:"path"`
+	Password    string         `json:"password"`
+	Options     Options        `json:"options"`
+}
+
+type Backup struct {
+	Id           string     `json:"id"`
+	Path         string     `json:"path"`
+	Name         string     `json:"name"`
+	Cron         string     `json:"cron"`
+	BackupParams [][]string `json:"backup_params"`
+	Targets      []string   `json:"targets"`
+}
+
+type Schedule struct {
+	Id               string `json:"id"`
+	Action           string `json:"action"`
+	BackupId         string `json:"backup_id"`
+	ToRepositoryId   string `json:"to_repository_id"`
+	FromRepositoryId string `json:"from_repository_id"`
+	Cron             string `json:"cron"`
+	Active           bool   `json:"active"`
+}
+
+type Config struct {
+	Mounts       []Mount      `json:"mounts"`
+	Repositories []Repository `json:"repositories"`
+	Backups      []Backup     `json:"backups"`
+	Schedules    []Schedule   `json:"schedules"`
+}
+
 // NewApp creates a new App application struct
 func NewApp(restic *Restic, scheduler *Scheduler, settings *Settings) *App {
 	return &App{restic: restic, scheduler: scheduler, settings: settings}
@@ -37,7 +131,11 @@ func (a *App) toggleSysTrayIcon() {
 		gocron.DurationJob(500*time.Millisecond),
 		gocron.NewTask(func() {
 			if def {
-				if len(a.scheduler.RunningJobs) > 0 {
+				running := funk.Filter(
+					a.scheduler.Jobs,
+					func(j Job) bool { return j.Running == true },
+				).([]Job)
+				if len(running) > 0 {
 					systray.SetIcon(active_icon)
 				}
 				def = false
diff --git a/frontend/components/Schedule/List.vue b/frontend/components/Schedule/List.vue
index 295a269..a415d95 100644
--- a/frontend/components/Schedule/List.vue
+++ b/frontend/components/Schedule/List.vue
@@ -3,6 +3,13 @@
 		<h1 class="text-yellow-500 font-bold mb-3"><UIcon name="i-heroicons-clock" class="mr-2" dynamic />Schedules</h1>
 
 		<UTable :rows="useSettings().settings?.schedules" :columns="columns" class="bg-gray-950 rounded-xl bg-opacity-50 shadow-lg" @select="">
+			<template #id-data="{ row }">
+				<div class="inline-flex items-center gap-1">
+					<UTooltip :text="row.id"
+						><span class="text-gray-400">{{ row.id.split('-')[0] }}...</span></UTooltip
+					>
+				</div>
+			</template>
 			<template #task-data="{ row }">
 				<div class="inline-flex items-center gap-1">
 					<span v-if="row.action === 'backup'"
@@ -25,6 +32,14 @@
 						<span>{{ useSettings().settings?.repositories.find((r: Repository) => r?.id === row.to_repository_id)?.name || '' }}</span></span
 					>
 				</div>
+				<div v-if="useJobs().scheduleProgress(row.id) !== null">
+					<UProgress :value="useJobs().scheduleProgress(row.id).percent_done * 100" class="mt-2" color="sky" />
+					<div class="text-xs opacity-50 flex justify-between mt-2">
+						<span>{{ useJobs().scheduleProgress(row.id).files_done }}/{{ useJobs().scheduleProgress(row.id).total_files }} files</span>
+						<span>{{ humanFileSize(useJobs().scheduleProgress(row.id).bytes_done) }}/{{ humanFileSize(useJobs().scheduleProgress(row.id).total_bytes) }}</span>
+						<span>{{ useJobs().scheduleProgress(row.id).seconds_remaining || 'unknown' }} seconds remaining</span>
+					</div>
+				</div>
 			</template>
 			<template #status-data="{ row }">
 				<div v-if="row.active">
@@ -53,9 +68,10 @@
 <script setup lang="ts">
 	import cronstrue from 'cronstrue'
 	const columns = [
+		{ key: 'id', class: 'w-32', label: 'ID' },
 		{ key: 'status', label: 'Status', class: 'w-32' },
-		{ key: 'task', label: 'Task' },
-		{ key: 'cron', label: 'Scheduled' },
+		{ key: 'task', label: 'Task', class: 'w-128' },
+		{ key: 'cron', label: 'Scheduled', class: 'w-32' },
 		{ key: 'actions', class: 'w-10' },
 	]
 
diff --git a/frontend/composables/useJobs.ts b/frontend/composables/useJobs.ts
index 113b141..52bca34 100644
--- a/frontend/composables/useJobs.ts
+++ b/frontend/composables/useJobs.ts
@@ -1,8 +1,15 @@
 export const useJobs = defineStore('useJobs', () => {
-	const running = ref<Awaited<ReturnType<typeof GetBackupJobs>>>([])
+	const running = ref([])
+	const progress = ref([])
 
 	function scheduleIsRunning(id: string) {
-		return running.value?.find((job: BackupJob) => job.schedule.id === id) ? true : false
+		return running.value?.find((job: any) => job.id === id) ? true : false
+	}
+
+	function scheduleProgress(id: string): any | null {
+		const job: any = running.value?.find((job: any) => job.id === id)
+		if (job) return job.out
+		return null
 	}
 
 	function repoIsRunning(id: string) {
@@ -18,7 +25,9 @@ export const useJobs = defineStore('useJobs', () => {
 
 	return {
 		running,
+		progress,
 		scheduleIsRunning,
+		scheduleProgress,
 		repoIsRunning,
 		repoIsSynching,
 		backupIsRunning,
diff --git a/frontend/composables/useSocket.ts b/frontend/composables/useSocket.ts
index 7acd762..49e42bf 100644
--- a/frontend/composables/useSocket.ts
+++ b/frontend/composables/useSocket.ts
@@ -1,12 +1,21 @@
 export const useSocket = defineStore('useSocket', () => {
 	function init() {
-		const jobsocket = new WebSocket('ws://127.0.0.1:11278/api/ws')
-		jobsocket.onmessage = (event) => {
+		const socket = new WebSocket('ws://127.0.0.1:11278/api/ws')
+		socket.onmessage = (event) => {
 			try {
 				const data = JSON.parse(event.data)
-				useJobs().running = data.jobs || []
-				useLogs().out = data.out
-				useLogs().err = data.err
+				console.log(data)
+				useJobs().running =
+					data.map((j: any) => {
+						try {
+							j.out = JSON.parse(j.out)
+						} catch {
+							j.out = {}
+						}
+						return j
+					}) || []
+				// useLogs().out = data.out
+				// useLogs().err = data.err
 			} catch (e) {
 				useJobs().running = []
 				console.error(e)
diff --git a/go.mod b/go.mod
index 989f0bc..c80b27f 100644
--- a/go.mod
+++ b/go.mod
@@ -12,6 +12,7 @@ require (
 	github.com/gofiber/contrib/websocket v1.3.0
 	github.com/gofiber/fiber/v2 v2.51.0
 	github.com/google/uuid v1.5.0
+	github.com/thoas/go-funk v0.9.3
 	github.com/wailsapp/wails/v2 v2.7.1
 )
 
diff --git a/go.sum b/go.sum
index 0f8a622..db8ea46 100644
--- a/go.sum
+++ b/go.sum
@@ -74,11 +74,14 @@ github.com/samber/lo v1.38.1/go.mod h1:+m/ZKRl6ClXCE2Lgf3MsQlWfh4bn1bz6CXEOxnEXn
 github.com/savsgio/gotils v0.0.0-20230208104028-c358bd845dee h1:8Iv5m6xEo1NR1AvpV+7XmhI4r39LGNzwUL4YpMuL5vk=
 github.com/savsgio/gotils v0.0.0-20230208104028-c358bd845dee/go.mod h1:qwtSXrKuJh/zsFQ12yEE89xfCrGKK63Rr7ctU/uCo4g=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/tevino/abool v0.0.0-20220530134649-2bfc934cb23c h1:coVla7zpsycc+kA9NXpcvv2E4I7+ii6L5hZO2S6C3kw=
 github.com/tevino/abool v0.0.0-20220530134649-2bfc934cb23c/go.mod h1:qc66Pna1RiIsPa7O4Egxxs9OqkuxDX55zznh9K07Tzg=
+github.com/thoas/go-funk v0.9.3 h1:7+nAEx3kn5ZJcnDm2Bh23N2yOtweO14bi//dvRtgLpw=
+github.com/thoas/go-funk v0.9.3/go.mod h1:+IWnUfUmFO1+WVYQWQtIJHeRRdaIyyYglZN7xzUPe4Q=
 github.com/tkrajina/go-reflector v0.5.6 h1:hKQ0gyocG7vgMD2M3dRlYN6WBBOmdoOzJ6njQSepKdE=
 github.com/tkrajina/go-reflector v0.5.6/go.mod h1:ECbqLgccecY5kPmPmXg1MrHW585yMcDkVl6IvJe64T4=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
@@ -125,6 +128,7 @@ golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
diff --git a/main.go b/main.go
index 55bb5af..1aacddf 100644
--- a/main.go
+++ b/main.go
@@ -14,14 +14,21 @@ import (
 //go:embed all:frontend/.output/public
 var assets embed.FS
 
+type ChanMsg struct {
+	Id       string   `json:"id"`
+	Out      string   `json:"out"`
+	Schedule Schedule `json:"schedule"`
+}
+
 func main() {
 	errb := bytes.NewBuffer([]byte{})
 	outb := bytes.NewBuffer([]byte{})
-	restic := NewRestic(errb, outb)
+	outputChan := make(chan ChanMsg)
 	settings := NewSettings()
-	if scheduler, err := NewScheduler(settings, restic); err == nil {
+	restic := NewRestic(errb, outb, settings)
+	if scheduler, err := NewScheduler(settings, restic, &outputChan); err == nil {
 		(scheduler).RescheduleBackups()
-		go RunServer(scheduler, restic, settings, errb, outb)
+		go RunServer(scheduler, restic, settings, errb, outb, &outputChan)
 		Desktop(scheduler, restic, settings)
 	} else {
 		fmt.Println("SCHEDULER ERROR", err)
diff --git a/restic.go b/restic.go
index 93fac87..33b4c90 100644
--- a/restic.go
+++ b/restic.go
@@ -1,81 +1,38 @@
 package main
 
 import (
+	"bufio"
 	"bytes"
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"os"
 	"os/exec"
 	"strings"
-	"time"
 )
 
 type Restic struct {
-	errb *bytes.Buffer
-	outb *bytes.Buffer
+	errb     *bytes.Buffer
+	outb     *bytes.Buffer
+	settings *Settings
 }
 
-func NewRestic(errb *bytes.Buffer, outb *bytes.Buffer) *Restic {
+func NewRestic(errb *bytes.Buffer, outb *bytes.Buffer, settings *Settings) *Restic {
 	r := &Restic{}
 	r.errb = errb
 	r.outb = outb
+	r.settings = settings
 	return r
 }
 
-type B2Options struct {
-	B2AccountId  string `json:"b2_account_id"`
-	B2AccountKey string `json:"b2_account_key"`
-}
-
-type AzureOptions struct {
-	AzureAccountName    string `json:"azure_account_name"`
-	AzureAccountKey     string `json:"azure_account_key"`
-	AzureAccountSas     string `json:"azure_account_sas"`
-	AzureEndpointSuffix string `json:"azure_endpoint_suffix"`
-}
-
-type Options struct {
-	B2Options
-	AzureOptions
-}
-
-type RepositoryType int32
-
-const (
-	LOCAL  RepositoryType = iota
-	B2     RepositoryType = iota
-	AWS    RepositoryType = iota
-	AZURE  RepositoryType = iota
-	GOOGLE RepositoryType = iota
-)
-
-type Snapshot struct {
-	Id             string    `json:"id"`
-	Time           time.Time `json:"time"`
-	Paths          []string  `json:"paths"`
-	Hostname       string    `json:"hostname"`
-	Username       string    `json:"username"`
-	UID            uint32    `json:"uid"`
-	GID            uint32    `json:"gid"`
-	ShortId        string    `json:"short_id"`
-	Tags           []string  `json:"tags"`
-	ProgramVersion string    `json:"program_version"`
-}
-
-type FileDescriptor struct {
-	Name  string `json:"name"`
-	Type  string `json:"type"`
-	Path  string `json:"path"`
-	Size  uint32 `json:"size"`
-	Mtime string `json:"mtime"`
-}
-
 func (r *Restic) core(
 	repository Repository,
 	cmd []string,
 	envs []string,
-	sctx *ScheduleContext,
+	ctx *context.Context,
+	cancel *context.CancelFunc,
+	ch *chan string,
 ) (string, error) {
 
 	cmds := []string{"-r", repository.Path, "--json"}
@@ -83,24 +40,52 @@ func (r *Restic) core(
 	var sout bytes.Buffer
 	var serr bytes.Buffer
 	var c *exec.Cmd
-	if sctx != nil {
-		c = exec.CommandContext(sctx.Ctx, "/usr/bin/restic", cmds...)
-		defer sctx.Cancel()
+	if ctx != nil {
+		c = exec.CommandContext(*ctx, "/usr/bin/restic", cmds...)
+		if cancel != nil {
+
+			defer (*cancel)()
+		}
 	} else {
 		c = exec.Command("/usr/bin/restic", cmds...)
 	}
-	c.Stderr = &serr
-	c.Stdout = &sout
+
+	stdout, err := c.StdoutPipe()
+
+	if err == nil {
+		go func() {
+			scanner := bufio.NewScanner(stdout)
+			scanner.Split(bufio.ScanLines)
+			for scanner.Scan() {
+
+				if ch != nil {
+					// fmt.Println(t)
+					go func(t string) {
+						*ch <- t
+					}(scanner.Text())
+				}
+				sout.WriteString(scanner.Text())
+			}
+		}()
+	}
+
 	c.Env = append(
 		os.Environ(),
 		"RESTIC_PASSWORD="+repository.Password,
+		"RESTIC_PROGRESS_FPS=5",
 	)
 
-	err := c.Start()
+	err = c.Start()
 	if err != nil {
 		fmt.Println(err)
 	}
 	c.Wait()
+	go func() {
+		if ch != nil {
+			*ch <- ""
+		}
+	}()
+	// fmt.Println(sp.Data)
 	r.errb.Write(serr.Bytes())
 	r.outb.Write(sout.Bytes())
 
@@ -113,7 +98,7 @@ func (r *Restic) core(
 }
 
 func (r *Restic) Exec(repository Repository, cmds []string, envs []string) (string, error) {
-	if data, err := r.core(repository, cmds, envs, nil); err != nil {
+	if data, err := r.core(repository, cmds, envs, nil, nil, nil); err != nil {
 		return "", err
 	} else {
 		return data, nil
@@ -125,7 +110,7 @@ func (r *Restic) BrowseSnapshot(
 	snapshotId string,
 	path string,
 ) ([]FileDescriptor, error) {
-	if res, err := r.core(repository, []string{"ls", "-l", "--human-readable", snapshotId, path}, []string{}, nil); err == nil {
+	if res, err := r.core(repository, []string{"ls", "-l", "--human-readable", snapshotId, path}, []string{}, nil, nil, nil); err == nil {
 		res = strings.ReplaceAll(res, "}", "},")
 		res = strings.ReplaceAll(res, "\n", "")
 		res = "[" + res + "]"
@@ -145,14 +130,17 @@ func (r *Restic) BrowseSnapshot(
 }
 
 func (r *Restic) RunSchedule(
-	sctx *ScheduleContext,
-	action string,
-	backup *Backup,
-	toRepository *Repository,
-	fromRepository *Repository,
+	job *Job,
 ) {
 
-	switch action {
+	if job == nil {
+		return
+	}
+	toRepository := r.settings.GetRepositoryById(job.Schedule.ToRepositoryId)
+	fromRepository := r.settings.GetRepositoryById(job.Schedule.FromRepositoryId)
+	backup := r.settings.GetBackupById(job.Schedule.BackupId)
+
+	switch job.Schedule.Action {
 	case "backup":
 		if backup == nil || toRepository == nil {
 			fmt.Println("Nope!")
@@ -165,7 +153,7 @@ func (r *Restic) RunSchedule(
 
 		fmt.Println(cmds)
 
-		_, err := r.core(*toRepository, cmds, []string{}, sctx)
+		_, err := r.core(*toRepository, cmds, []string{}, &job.Ctx, &job.Cancel, &job.Chan)
 		if err != nil {
 			fmt.Println(err)
 		}
@@ -190,9 +178,16 @@ func (r *Restic) RunSchedule(
 		for _, p := range toRepository.PruneParams {
 			cmds = append(cmds, p...)
 		}
-		_, err := r.core(*toRepository, []string{"unlock"}, []string{}, sctx)
+		_, err := r.core(
+			*toRepository,
+			[]string{"unlock"},
+			[]string{},
+			&job.Ctx,
+			&job.Cancel,
+			&job.Chan,
+		)
 		if err == nil {
-			_, err := r.core(*toRepository, cmds, []string{}, sctx)
+			_, err := r.core(*toRepository, cmds, []string{}, &job.Ctx, &job.Cancel, &job.Chan)
 			if err != nil {
 				fmt.Println(err)
 			}
diff --git a/scheduler.go b/scheduler.go
index 6ed00cc..d5d428f 100644
--- a/scheduler.go
+++ b/scheduler.go
@@ -7,42 +7,35 @@ import (
 
 	"github.com/go-co-op/gocron/v2"
 	"github.com/google/uuid"
+	"github.com/thoas/go-funk"
 )
 
 type Job struct {
+	Id       string `json:"id"`
 	job      gocron.Job
-	schedule Schedule
-}
-
-type ScheduleContext struct {
-	Id     string
-	Ctx    context.Context
-	Cancel context.CancelFunc
-}
-
-type RunningJob struct {
-	JobId    uuid.UUID `json:"job_id"`
-	Schedule Schedule  `json:"schedule"`
+	Schedule Schedule `json:"schedule"`
+	Running  bool     `json:"running"`
+	Force    bool     `json:"force"`
+	Ctx      context.Context
+	Cancel   context.CancelFunc
+	Chan     chan string
 }
 
 type Scheduler struct {
-	gocron            gocron.Scheduler
-	restic            *Restic
-	RunningJobs       []RunningJob
-	ScheduleContexts  []ScheduleContext
-	Jobs              []Job
-	ForceInactiveJobs []string
-	jmu               sync.Mutex
-	settings          *Settings
+	gocron   gocron.Scheduler
+	restic   *Restic
+	Jobs     []Job
+	jmu      sync.Mutex
+	settings *Settings
+	outputCh *chan ChanMsg
 }
 
-func NewScheduler(settings *Settings, restic *Restic) (*Scheduler, error) {
+func NewScheduler(settings *Settings, restic *Restic, ch *chan ChanMsg) (*Scheduler, error) {
 
 	s := &Scheduler{}
 	s.settings = settings
 	s.restic = restic
-	s.ForceInactiveJobs = []string{}
-	s.RunningJobs = []RunningJob{}
+	s.outputCh = ch
 	if gc, err := gocron.NewScheduler(); err == nil {
 		s.gocron = gc
 		s.gocron.Start()
@@ -53,12 +46,12 @@ func NewScheduler(settings *Settings, restic *Restic) (*Scheduler, error) {
 
 }
 
-func (s *Scheduler) RunJobByName(name string) {
-	fmt.Println("should run", name)
-	for _, j := range s.Jobs {
-		if j.job.Name() == name {
-			fmt.Println("Running job by name", name)
-			s.ForceInactiveJobs = append(s.ForceInactiveJobs, name)
+func (s *Scheduler) RunJobById(id string) {
+	fmt.Println("should run", id)
+	for i, j := range s.Jobs {
+		if j.Id == id {
+			fmt.Println("Running job by name", id)
+			s.Jobs[i].Force = true
 			if err := j.job.RunNow(); err != nil {
 				fmt.Println("Error running job manually", err)
 			}
@@ -67,85 +60,79 @@ func (s *Scheduler) RunJobByName(name string) {
 	}
 }
 
-func (s *Scheduler) StopJobByName(name string) {
-	for _, c := range s.ScheduleContexts {
-		if c.Id == name {
-			c.Cancel()
+func (s *Scheduler) StopJobById(id string) {
+	for _, j := range s.Jobs {
+		if j.Id == id {
+			j.Cancel()
 			break
 		}
 	}
 }
 
-func (s *Scheduler) DeleteRunningJob(jobID uuid.UUID) {
+func (s *Scheduler) DeleteRunningJob(id string) {
 	s.jmu.Lock()
 	defer s.jmu.Unlock()
-	for i, j := range s.RunningJobs {
-		if j.JobId == jobID {
-			fmt.Println("Deleting forced inactive job", jobID)
-			s.RunningJobs = append(
-				s.RunningJobs[:i],
-				s.RunningJobs[i+1:]...)
+	for i, j := range s.Jobs {
+		if j.Id == id {
+			fmt.Println("Deleting forced inactive job", id)
+			s.Jobs[i].Running = false
+			s.Jobs[i].Force = false
 			break
 		}
 	}
 }
 
-func (s *Scheduler) RecreateCtx(name string) {
-	for i, c := range s.ScheduleContexts {
-		if c.Id == name {
-			fmt.Println("Recreating context for job", name)
-			ctx, cancel := context.WithCancel(context.Background())
-			s.ScheduleContexts[i].Ctx = ctx
-			s.ScheduleContexts[i].Cancel = cancel
-			break
+func (s *Scheduler) FindJobById(id string) *Job {
+	s.jmu.Lock()
+	defer s.jmu.Unlock()
+	for _, j := range s.Jobs {
+		if j.Id == id {
+			return &j
 		}
 	}
+	return nil
 }
 
-func (s *Scheduler) DeleteForcedInactiveJob(name string) {
+func (s *Scheduler) SetRunningJob(id string) {
 	s.jmu.Lock()
 	defer s.jmu.Unlock()
-	for i, j := range s.ForceInactiveJobs {
-		if j == name {
-			fmt.Println("Deleting forced inactive job", name)
-			s.ForceInactiveJobs = append(
-				s.ForceInactiveJobs[:i],
-				s.ForceInactiveJobs[i+1:]...)
+	for i, j := range s.Jobs {
+		if j.Id == id {
+			fmt.Println("Deleting forced inactive job", id)
+			s.Jobs[i].Running = true
 			break
 		}
 	}
 }
 
-func (s *Scheduler) GetRunningJobs() []RunningJob {
-	s.jmu.Lock()
-	defer s.jmu.Unlock()
-	return s.RunningJobs
-}
-
-func (s *Scheduler) GetContextById(id string) *ScheduleContext {
-	for _, sc := range s.ScheduleContexts {
-		if sc.Id == id {
-			return &sc
+func (s *Scheduler) RecreateCtx(name string) {
+	for i, j := range s.Jobs {
+		if j.job.Name() == name {
+			fmt.Println("Recreating context for job", name)
+			ctx, cancel := context.WithCancel(context.Background())
+			s.Jobs[i].Ctx = ctx
+			s.Jobs[i].Cancel = cancel
+			break
 		}
 	}
-	return nil
+}
+
+func (s *Scheduler) GetRunningJobs() []Job {
+	s.jmu.Lock()
+	defer s.jmu.Unlock()
+	return funk.Filter(s.Jobs, func(j Job) bool { return j.Running == true }).([]Job)
 }
 
 func (s *Scheduler) RescheduleBackups() {
 
 	s.Jobs = []Job{}
-	s.ScheduleContexts = []ScheduleContext{}
-	s.RunningJobs = []RunningJob{}
-	s.ForceInactiveJobs = []string{}
 	fmt.Println("Rescheduling backups")
 
 	config := s.settings.Config
 
 	for i := range config.Schedules {
 		schedule := config.Schedules[i]
-		ctx, cancel := context.WithCancel(context.Background())
-		sctx := ScheduleContext{Id: schedule.Id, Ctx: ctx, Cancel: cancel}
-		s.ScheduleContexts = append(s.ScheduleContexts, sctx)
+
 		jobDef := gocron.OneTimeJob(gocron.OneTimeJobStartImmediately())
 
 		if schedule.Cron != "" {
@@ -155,20 +142,15 @@ func (s *Scheduler) RescheduleBackups() {
 		j, err := s.gocron.NewJob(
 			jobDef,
 			gocron.NewTask(func() {
-				toRepository := s.settings.GetRepositoryById(schedule.ToRepositoryId)
-				fromRepository := s.settings.GetRepositoryById(schedule.FromRepositoryId)
-				backup := s.settings.GetBackupById(schedule.BackupId)
-				if !schedule.Active && !StringArrayContains(s.ForceInactiveJobs, schedule.Id) {
+
+				existing := s.FindJobById(schedule.Id)
+				isForced := existing != nil && existing.Force == true
+				if !schedule.Active && !isForced {
 					fmt.Println("MISSING", schedule.Id)
 					return
 				}
-				s.restic.RunSchedule(
-					s.GetContextById(schedule.Id),
-					schedule.Action,
-					backup,
-					toRepository,
-					fromRepository,
-				)
+				s.restic.RunSchedule(s.FindJobById(schedule.Id))
+
 			}),
 			gocron.WithName(schedule.Id),
 			gocron.WithTags(
@@ -179,29 +161,19 @@ func (s *Scheduler) RescheduleBackups() {
 			gocron.WithEventListeners(
 				gocron.BeforeJobRuns(func(jobID uuid.UUID, jobName string) {
 					fmt.Println("before job run")
-					s.jmu.Lock()
-					defer s.jmu.Unlock()
-					s.RunningJobs = append(
-						s.RunningJobs,
-						RunningJob{
-							JobId:    jobID,
-							Schedule: schedule,
-						},
-					)
+					s.SetRunningJob(jobName)
 				}),
 				gocron.AfterJobRuns(
 					func(jobID uuid.UUID, jobName string) {
 						fmt.Println("after job run")
-						s.DeleteRunningJob(jobID)
-						s.DeleteForcedInactiveJob(jobName)
+						s.DeleteRunningJob(jobName)
 						s.RecreateCtx(jobName)
 					},
 				),
 				gocron.AfterJobRunsWithError(
 					func(jobID uuid.UUID, jobName string, err error) {
 						fmt.Println("after job run with error", err)
-						s.DeleteRunningJob(jobID)
-						s.DeleteForcedInactiveJob(jobName)
+						s.DeleteRunningJob(jobName)
 						s.RecreateCtx(jobName)
 					},
 				),
@@ -212,9 +184,25 @@ func (s *Scheduler) RescheduleBackups() {
 			continue
 		}
 
+		ctx, cancel := context.WithCancel(context.Background())
+		ch := make(chan string)
+		go func(c chan string) {
+			for msg := range c {
+				*s.outputCh <- ChanMsg{Id: schedule.Id, Out: msg, Schedule: schedule}
+			}
+		}(ch)
 		s.Jobs = append(
 			s.Jobs,
-			Job{job: j, schedule: schedule},
+			Job{
+				job:      j,
+				Schedule: schedule,
+				Id:       schedule.Id,
+				Running:  false,
+				Force:    false,
+				Ctx:      ctx,
+				Cancel:   cancel,
+				Chan:     ch,
+			},
 		)
 
 	}
diff --git a/server.go b/server.go
index c170783..3a70610 100644
--- a/server.go
+++ b/server.go
@@ -6,12 +6,12 @@ import (
 	"log"
 	"os"
 	"os/exec"
-	"time"
 
 	"github.com/goccy/go-json"
 	"github.com/gofiber/contrib/websocket"
 	"github.com/gofiber/fiber/v2"
 	"github.com/gofiber/fiber/v2/middleware/cors"
+	"github.com/thoas/go-funk"
 )
 
 type BrowseData struct {
@@ -28,12 +28,25 @@ type RestoreData struct {
 	ToPath   string `json:"to_path"`
 }
 
+type Output struct {
+	Id  string `json:"id"`
+	Out any    `json:"out"`
+}
+
+type MsgJob struct {
+	Id       string   `json:"id"`
+	Schedule Schedule `json:"schedule"`
+	Running  bool     `json:"running"`
+	Force    bool     `json:"force"`
+}
+
 func RunServer(
 	scheduler *Scheduler,
 	restic *Restic,
 	settings *Settings,
 	errb *bytes.Buffer,
 	outb *bytes.Buffer,
+	outputChan *chan ChanMsg,
 ) {
 	server := fiber.New()
 	server.Use(cors.New())
@@ -53,31 +66,120 @@ func RunServer(
 	api.Get("/ws", websocket.New(func(c *websocket.Conn) {
 
 		defer c.Close()
+
+		// outs := []Output{}
+
+		// listen := func() {
+		// 	for {
+		// 		jobs := scheduler.GetRunningJobs()
+		// 		for _, j := range jobs {
+		// 			if funk.Find(outs, func(out Output) bool { return out.Id == j.Id }) == nil {
+		// 				outs = append(outs, Output{Id: j.Id, Out: map[string]string{}})
+		// 			}
+		// 			go func(j Job) {
+		// 				d := <-j.Chan
+		// 				for i, out := range outs {
+		// 					if out.Id == j.Id {
+		// 						var data any
+		// 						if err := json.Unmarshal([]byte(d), &data); err == nil {
+		// 							outs[i].Out = data
+		// 						} else {
+		// 							outs[i].Out = map[string]string{}
+		// 						}
+		// 						break
+		// 					}
+		// 				}
+		// 				data := make(map[string]any)
+		// 				data["jobs"] = funk.Map(jobs, func(j Job) MsgJob {
+		// 					return MsgJob{
+		// 						Id:       j.Id,
+		// 						Schedule: j.Schedule,
+		// 						Running:  j.Running,
+		// 						Force:    j.Force,
+		// 					}
+		// 				})
+		// 				data["outputs"] = outs
+		// 				time.Sleep(100 * time.Millisecond)
+
+		// 				if d, err := json.Marshal(data); err == nil {
+		// 					if err = c.WriteMessage(websocket.TextMessage, d); err != nil {
+		// 						log.Println("Error writing to socket:", err)
+		// 					}
+		// 				} else {
+		// 					log.Println("Error marshalling data:", err)
+		// 				}
+		// 				time.Sleep(100 * time.Millisecond)
+		// 			}(j)
+
+		// 		}
+
+		// 	}
+
+		// }
+
+		outputs := []ChanMsg{}
+
 		for {
-			jobs := scheduler.GetRunningJobs()
-			data := make(map[string]any)
-			data["jobs"] = jobs
-			data["out"] = string(outb.Bytes())
-			data["err"] = string(errb.Bytes())
-			if d, err := json.Marshal(data); err == nil {
-				if err = c.WriteMessage(websocket.TextMessage, d); err != nil {
-					log.Println("Error writing to socket:", err)
+			select {
+			case d := <-*outputChan:
+				if funk.Find(
+					outputs,
+					func(out ChanMsg) bool { return out.Id == d.Id },
+				) == nil {
+					outputs = append(outputs, d)
+				} else {
+					for i, out := range outputs {
+						if out.Id == d.Id {
+							outputs[i] = d
+							break
+						}
+					}
 				}
-			} else {
-				log.Println("Error marshalling data:", err)
+				// var data map[string]any
+				// data["jobs"] = outputs
+				if j, err := json.Marshal(funk.Filter(outputs, func(o ChanMsg) bool { return o.Out != "" && o.Out != "{}" })); err == nil {
+					if err = c.WriteMessage(websocket.TextMessage, j); err != nil {
+						log.Println("Error writing to socket:", err)
+					}
+				} else {
+					log.Println("Error marshalling data:", err)
+				}
+				fmt.Println(d)
 			}
-			time.Sleep(1 * time.Second)
 		}
 
+		// for {
+		// time.Sleep(1 * time.Second)
+		// fmt.Println(outputs)
+
+		// data["out"] = string(outb.Bytes())
+
+		// data["outputs"] = funk.Map(filtered, func(o ScheduleOutput) *ScheduleOutput {
+		// 	u := scheduler.GetOutputById(o.Id)
+		// 	// fmt.Println(*u)
+		// 	return u
+		// })
+		// fmt.Println(data["outputs"])
+		// data["err"] = string(errb.Bytes())
+		// if d, err := json.Marshal(data); err == nil {
+		// 	if err = c.WriteMessage(websocket.TextMessage, d); err != nil {
+		// 		log.Println("Error writing to socket:", err)
+		// 	}
+		// } else {
+		// 	log.Println("Error marshalling data:", err)
+		// }
+		// time.Sleep(300 * time.Millisecond)
+		// }
+
 	}))
 
 	api.Get("/schedules/:id/:action", func(c *fiber.Ctx) error {
 		switch c.Params("action") {
 		case "run":
-			scheduler.RunJobByName(c.Params("id"))
+			scheduler.RunJobById(c.Params("id"))
 			break
 		case "stop":
-			scheduler.StopJobByName(c.Params("id"))
+			scheduler.StopJobById(c.Params("id"))
 			break
 		}
 
@@ -153,7 +255,6 @@ func RunServer(
 				c.SendStatus(500)
 				return c.SendString(err.Error())
 			}
-			fmt.Println(data.Path)
 
 			go func(id string) {
 				restic.Exec(
@@ -170,7 +271,6 @@ func RunServer(
 				c.SendStatus(500)
 				return c.SendString(err.Error())
 			}
-			fmt.Println("unmounting")
 
 			e := exec.Command("/usr/bin/umount", "-l", data.Path)
 			e.Output()
diff --git a/settings.go b/settings.go
index dc8a686..4731242 100644
--- a/settings.go
+++ b/settings.go
@@ -9,51 +9,6 @@ import (
 	"github.com/adrg/xdg"
 )
 
-type Settings struct {
-	Config Config
-}
-
-type Mount struct {
-	RepositoryId string `json:"repository_id"`
-	Path         string `json:"path"`
-}
-
-type Repository struct {
-	Id          string         `json:"id"`
-	Name        string         `json:"name"`
-	Type        RepositoryType `json:"type"`
-	PruneParams [][]string     `json:"prune_params"`
-	Path        string         `json:"path"`
-	Password    string         `json:"password"`
-	Options     Options        `json:"options"`
-}
-
-type Backup struct {
-	Id           string     `json:"id"`
-	Path         string     `json:"path"`
-	Name         string     `json:"name"`
-	Cron         string     `json:"cron"`
-	BackupParams [][]string `json:"backup_params"`
-	Targets      []string   `json:"targets"`
-}
-
-type Schedule struct {
-	Id               string `json:"id"`
-	Action           string `json:"action"`
-	BackupId         string `json:"backup_id"`
-	ToRepositoryId   string `json:"to_repository_id"`
-	FromRepositoryId string `json:"from_repository_id"`
-	Cron             string `json:"cron"`
-	Active           bool   `json:"active"`
-}
-
-type Config struct {
-	Mounts       []Mount      `json:"mounts"`
-	Repositories []Repository `json:"repositories"`
-	Backups      []Backup     `json:"backups"`
-	Schedules    []Schedule   `json:"schedules"`
-}
-
 func NewSettings() *Settings {
 	s := &Settings{}
 	s.Config = s.readFile()
@@ -97,7 +52,6 @@ func settingsFile() string {
 }
 
 func (s *Settings) Save(data Config) error {
-
 	s.Config = data
 	fmt.Println("Saving settings")
 	if str, err := json.MarshalIndent(s.Config, " ", " "); err == nil {