diff --git a/models/user/setting_keys.go b/models/user/setting_keys.go
index 10255735b3177..e698a54332e2e 100644
--- a/models/user/setting_keys.go
+++ b/models/user/setting_keys.go
@@ -12,4 +12,6 @@ const (
 	UserActivityPubPrivPem = "activitypub.priv_pem"
 	// UserActivityPubPubPem is user's public key
 	UserActivityPubPubPem = "activitypub.pub_pem"
+	// SettingsKeyProfileRepoName is user's profile repo name
+	SettingsKeyProfileRepoName = "profile.repo_name"
 )
diff --git a/modules/structs/user.go b/modules/structs/user.go
index f68b92ac069e2..cf832901a7aa2 100644
--- a/modules/structs/user.go
+++ b/modules/structs/user.go
@@ -75,8 +75,9 @@ type UserSettings struct {
 	Theme         string `json:"theme"`
 	DiffViewStyle string `json:"diff_view_style"`
 	// Privacy
-	HideEmail    bool `json:"hide_email"`
-	HideActivity bool `json:"hide_activity"`
+	HideEmail       bool   `json:"hide_email"`
+	HideActivity    bool   `json:"hide_activity"`
+	ProfileRepoName string `json:"profile_repo_name"`
 }
 
 // UserSettingsOptions represents options to change user settings
@@ -90,8 +91,9 @@ type UserSettingsOptions struct {
 	Theme         *string `json:"theme"`
 	DiffViewStyle *string `json:"diff_view_style"`
 	// Privacy
-	HideEmail    *bool `json:"hide_email"`
-	HideActivity *bool `json:"hide_activity"`
+	HideEmail       *bool   `json:"hide_email"`
+	HideActivity    *bool   `json:"hide_activity"`
+	ProfileRepoName *string `json:"profile_repo_name"`
 }
 
 // RenameUserOption options when renaming a user
diff --git a/options/locale/locale_en-US.ini b/options/locale/locale_en-US.ini
index a7dd59ec3f91f..10bcbb5b38381 100644
--- a/options/locale/locale_en-US.ini
+++ b/options/locale/locale_en-US.ini
@@ -639,6 +639,7 @@ continue = Continue
 cancel = Cancel
 language = Language
 ui = Theme
+profile_repo_name = Profile repo name
 hidden_comment_types = Hidden comment types
 hidden_comment_types_description = Comment types checked here will not be shown inside issue pages. Checking "Label" for example removes all "<user> added/removed <label>" comments.
 hidden_comment_types.ref_tooltip = Comments where this issue was referenced from another issue/commit/…
diff --git a/routers/api/v1/user/settings.go b/routers/api/v1/user/settings.go
index 53794c82f8385..aa58f91345e87 100644
--- a/routers/api/v1/user/settings.go
+++ b/routers/api/v1/user/settings.go
@@ -78,5 +78,13 @@ func UpdateUserSettings(ctx *context.APIContext) {
 		return
 	}
 
+	if form.ProfileRepoName != nil {
+		err := user_model.SetUserSetting(ctx.Doer.ID, user_model.SettingsKeyProfileRepoName, *form.ProfileRepoName)
+		if err != nil {
+			ctx.InternalServerError(err)
+			return
+		}
+	}
+
 	ctx.JSON(http.StatusOK, convert.User2UserSettings(ctx.Doer))
 }
diff --git a/routers/web/repo/render/render.go b/routers/web/repo/render/render.go
new file mode 100644
index 0000000000000..db7383bfb5f0b
--- /dev/null
+++ b/routers/web/repo/render/render.go
@@ -0,0 +1,305 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package render
+
+import (
+	"bytes"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"net/url"
+	"path"
+	"strings"
+
+	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
+	"code.gitea.io/gitea/modules/base"
+	"code.gitea.io/gitea/modules/charset"
+	"code.gitea.io/gitea/modules/context"
+	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/lfs"
+	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/markup"
+	"code.gitea.io/gitea/modules/setting"
+	"code.gitea.io/gitea/modules/typesniffer"
+	"code.gitea.io/gitea/modules/util"
+)
+
+type FileInfo struct {
+	isTextFile bool
+	isLFSFile  bool
+	fileSize   int64
+	lfsMeta    *lfs.Pointer
+	St         typesniffer.SniffedType
+}
+
+func (f *FileInfo) IsTextFile() bool {
+	return f.isTextFile
+}
+
+func (f *FileInfo) IsLFSFile() bool {
+	return f.isLFSFile
+}
+
+func (f *FileInfo) FileSize() int64 {
+	return f.fileSize
+}
+
+func GetFileReader(repoID int64, blob *git.Blob) ([]byte, io.ReadCloser, *FileInfo, error) {
+	dataRc, err := blob.DataAsync()
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	buf := make([]byte, 1024)
+	n, _ := util.ReadAtMost(dataRc, buf)
+	buf = buf[:n]
+
+	st := typesniffer.DetectContentType(buf)
+	isTextFile := st.IsText()
+
+	// FIXME: what happens when README file is an image?
+	if !isTextFile || !setting.LFS.StartServer {
+		return buf, dataRc, &FileInfo{isTextFile, false, blob.Size(), nil, st}, nil
+	}
+
+	pointer, _ := lfs.ReadPointerFromBuffer(buf)
+	if !pointer.IsValid() { // fallback to plain file
+		return buf, dataRc, &FileInfo{isTextFile, false, blob.Size(), nil, st}, nil
+	}
+
+	meta, err := git_model.GetLFSMetaObjectByOid(db.DefaultContext, repoID, pointer.Oid)
+	if err != nil && err != git_model.ErrLFSObjectNotExist { // fallback to plain file
+		return buf, dataRc, &FileInfo{isTextFile, false, blob.Size(), nil, st}, nil
+	}
+
+	dataRc.Close()
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	dataRc, err = lfs.ReadMetaObject(pointer)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	buf = make([]byte, 1024)
+	n, err = util.ReadAtMost(dataRc, buf)
+	if err != nil {
+		dataRc.Close()
+		return nil, nil, nil, err
+	}
+	buf = buf[:n]
+
+	st = typesniffer.DetectContentType(buf)
+
+	return buf, dataRc, &FileInfo{st.IsText(), true, meta.Size, &meta.Pointer, st}, nil
+}
+
+func MarkupRender(ctx *context.Context, renderCtx *markup.RenderContext, input io.Reader) (escaped *charset.EscapeStatus, output string, err error) {
+	markupRd, markupWr := io.Pipe()
+	defer markupWr.Close()
+	done := make(chan struct{})
+	go func() {
+		sb := &strings.Builder{}
+		// We allow NBSP here this is rendered
+		escaped, _ = charset.EscapeControlReader(markupRd, sb, ctx.Locale, charset.RuneNBSP)
+		output = sb.String()
+		close(done)
+	}()
+	err = markup.Render(renderCtx, input, markupWr)
+	_ = markupWr.CloseWithError(err)
+	<-done
+	return escaped, output, err
+}
+
+// localizedExtensions prepends the provided language code with and without a
+// regional identifier to the provided extension.
+// Note: the language code will always be lower-cased, if a region is present it must be separated with a `-`
+// Note: ext should be prefixed with a `.`
+func localizedExtensions(ext, languageCode string) (localizedExts []string) {
+	if len(languageCode) < 1 {
+		return []string{ext}
+	}
+
+	lowerLangCode := "." + strings.ToLower(languageCode)
+
+	if strings.Contains(lowerLangCode, "-") {
+		underscoreLangCode := strings.ReplaceAll(lowerLangCode, "-", "_")
+		indexOfDash := strings.Index(lowerLangCode, "-")
+		// e.g. [.zh-cn.md, .zh_cn.md, .zh.md, _zh.md, .md]
+		return []string{lowerLangCode + ext, underscoreLangCode + ext, lowerLangCode[:indexOfDash] + ext, "_" + lowerLangCode[1:indexOfDash] + ext, ext}
+	}
+
+	// e.g. [.en.md, .md]
+	return []string{lowerLangCode + ext, ext}
+}
+
+// locate a README for a tree in one of the supported paths.
+//
+// entries is passed to reduce calls to ListEntries(), so
+// this has precondition:
+//
+//	entries == ctx.Repo.Commit.SubTree(ctx.Repo.TreePath).ListEntries()
+//
+// FIXME: There has to be a more efficient way of doing this
+func FindReadmeFileInEntries(ctx *context.Context, entries []*git.TreeEntry, tryWellKnownDirs bool) (string, *git.TreeEntry, error) {
+	// Create a list of extensions in priority order
+	// 1. Markdown files - with and without localisation - e.g. README.en-us.md or README.md
+	// 2. Txt files - e.g. README.txt
+	// 3. No extension - e.g. README
+	exts := append(localizedExtensions(".md", ctx.Locale.Language()), ".txt", "") // sorted by priority
+	extCount := len(exts)
+	readmeFiles := make([]*git.TreeEntry, extCount+1)
+
+	docsEntries := make([]*git.TreeEntry, 3) // (one of docs/, .gitea/ or .github/)
+	for _, entry := range entries {
+		if tryWellKnownDirs && entry.IsDir() {
+			// as a special case for the top-level repo introduction README,
+			// fall back to subfolders, looking for e.g. docs/README.md, .gitea/README.zh-CN.txt, .github/README.txt, ...
+			// (note that docsEntries is ignored unless we are at the root)
+			lowerName := strings.ToLower(entry.Name())
+			switch lowerName {
+			case "docs":
+				if entry.Name() == "docs" || docsEntries[0] == nil {
+					docsEntries[0] = entry
+				}
+			case ".gitea":
+				if entry.Name() == ".gitea" || docsEntries[1] == nil {
+					docsEntries[1] = entry
+				}
+			case ".github":
+				if entry.Name() == ".github" || docsEntries[2] == nil {
+					docsEntries[2] = entry
+				}
+			}
+			continue
+		}
+		if i, ok := util.IsReadmeFileExtension(entry.Name(), exts...); ok {
+			log.Debug("Potential readme file: %s", entry.Name())
+			if readmeFiles[i] == nil || base.NaturalSortLess(readmeFiles[i].Name(), entry.Blob().Name()) {
+				if entry.IsLink() {
+					target, err := entry.FollowLinks()
+					if err != nil && !git.IsErrBadLink(err) {
+						return "", nil, err
+					} else if target != nil && (target.IsExecutable() || target.IsRegular()) {
+						readmeFiles[i] = entry
+					}
+				} else {
+					readmeFiles[i] = entry
+				}
+			}
+		}
+	}
+	var readmeFile *git.TreeEntry
+	for _, f := range readmeFiles {
+		if f != nil {
+			readmeFile = f
+			break
+		}
+	}
+
+	if ctx.Repo.TreePath == "" && readmeFile == nil {
+		for _, subTreeEntry := range docsEntries {
+			if subTreeEntry == nil {
+				continue
+			}
+			subTree := subTreeEntry.Tree()
+			if subTree == nil {
+				// this should be impossible; if subTreeEntry exists so should this.
+				continue
+			}
+			var err error
+			childEntries, err := subTree.ListEntries()
+			if err != nil {
+				return "", nil, err
+			}
+
+			subfolder, readmeFile, err := FindReadmeFileInEntries(ctx, childEntries, false)
+			if err != nil && !git.IsErrNotExist(err) {
+				return "", nil, err
+			}
+			if readmeFile != nil {
+				return path.Join(subTreeEntry.Name(), subfolder), readmeFile, nil
+			}
+		}
+	}
+
+	return "", readmeFile, nil
+}
+
+func ReadmeFile(ctx *context.Context, subfolder string, readmeFile *git.TreeEntry, readmeTreelink string) {
+	target := readmeFile
+	if readmeFile != nil && readmeFile.IsLink() {
+		target, _ = readmeFile.FollowLinks()
+	}
+	if target == nil {
+		// if findReadmeFile() failed and/or gave us a broken symlink (which it shouldn't)
+		// simply skip rendering the README
+		return
+	}
+
+	ctx.Data["RawFileLink"] = ""
+	ctx.Data["ReadmeInList"] = true
+	ctx.Data["ReadmeExist"] = true
+	ctx.Data["FileIsSymlink"] = readmeFile.IsLink()
+
+	buf, dataRc, fInfo, err := GetFileReader(ctx.Repo.Repository.ID, target.Blob())
+	if err != nil {
+		ctx.ServerError("getFileReader", err)
+		return
+	}
+	defer dataRc.Close()
+
+	ctx.Data["FileIsText"] = fInfo.isTextFile
+	ctx.Data["FileName"] = path.Join(subfolder, readmeFile.Name())
+	ctx.Data["IsLFSFile"] = fInfo.isLFSFile
+
+	if fInfo.isLFSFile {
+		filenameBase64 := base64.RawURLEncoding.EncodeToString([]byte(readmeFile.Name()))
+		ctx.Data["RawFileLink"] = fmt.Sprintf("%s.git/info/lfs/objects/%s/%s", ctx.Repo.Repository.Link(), url.PathEscape(fInfo.lfsMeta.Oid), url.PathEscape(filenameBase64))
+	}
+
+	if !fInfo.isTextFile {
+		return
+	}
+
+	if fInfo.fileSize >= setting.UI.MaxDisplayFileSize {
+		// Pretend that this is a normal text file to display 'This file is too large to be shown'
+		ctx.Data["IsFileTooLarge"] = true
+		ctx.Data["IsTextFile"] = true
+		ctx.Data["FileSize"] = fInfo.fileSize
+		return
+	}
+
+	rd := charset.ToUTF8WithFallbackReader(io.MultiReader(bytes.NewReader(buf), dataRc))
+
+	if markupType := markup.Type(readmeFile.Name()); markupType != "" {
+		ctx.Data["IsMarkup"] = true
+		ctx.Data["MarkupType"] = markupType
+
+		ctx.Data["EscapeStatus"], ctx.Data["FileContent"], err = MarkupRender(ctx, &markup.RenderContext{
+			Ctx:          ctx,
+			RelativePath: path.Join(ctx.Repo.TreePath, readmeFile.Name()), // ctx.Repo.TreePath is the directory not the Readme so we must append the Readme filename (and path).
+			URLPrefix:    path.Join(readmeTreelink, subfolder),
+			Metas:        ctx.Repo.Repository.ComposeDocumentMetas(),
+			GitRepo:      ctx.Repo.GitRepo,
+		}, rd)
+		if err != nil {
+			log.Error("Render failed for %s in %-v: %v Falling back to rendering source", readmeFile.Name(), ctx.Repo.Repository, err)
+			buf := &bytes.Buffer{}
+			ctx.Data["EscapeStatus"], _ = charset.EscapeControlStringReader(rd, buf, ctx.Locale)
+			ctx.Data["FileContent"] = buf.String()
+		}
+	} else {
+		ctx.Data["IsPlainText"] = true
+		buf := &bytes.Buffer{}
+		ctx.Data["EscapeStatus"], err = charset.EscapeControlStringReader(rd, buf, ctx.Locale)
+		if err != nil {
+			log.Error("Read failed: %v", err)
+		}
+
+		ctx.Data["FileContent"] = buf.String()
+	}
+}
diff --git a/routers/web/repo/view_test.go b/routers/web/repo/render/render_test.go
similarity index 99%
rename from routers/web/repo/view_test.go
rename to routers/web/repo/render/render_test.go
index 73ba118823bf6..c0963c54f6298 100644
--- a/routers/web/repo/view_test.go
+++ b/routers/web/repo/render/render_test.go
@@ -2,7 +2,7 @@
 // Copyright 2014 The Gogs Authors. All rights reserved.
 // SPDX-License-Identifier: MIT
 
-package repo
+package render
 
 import (
 	"reflect"
diff --git a/routers/web/repo/view.go b/routers/web/repo/view.go
index cf719c49f0b29..10d9c0c8435c6 100644
--- a/routers/web/repo/view.go
+++ b/routers/web/repo/view.go
@@ -7,7 +7,6 @@ package repo
 import (
 	"bytes"
 	gocontext "context"
-	"encoding/base64"
 	"fmt"
 	"io"
 	"net/http"
@@ -32,15 +31,14 @@ import (
 	"code.gitea.io/gitea/modules/context"
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/highlight"
-	"code.gitea.io/gitea/modules/lfs"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/markup"
 	repo_module "code.gitea.io/gitea/modules/repository"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/structs"
-	"code.gitea.io/gitea/modules/typesniffer"
 	"code.gitea.io/gitea/modules/util"
 	"code.gitea.io/gitea/routers/web/feed"
+	"code.gitea.io/gitea/routers/web/repo/render"
 	issue_service "code.gitea.io/gitea/services/issue"
 
 	"github.com/nektos/act/pkg/model"
@@ -55,99 +53,6 @@ const (
 	tplMigrating    base.TplName = "repo/migrate/migrating"
 )
 
-// locate a README for a tree in one of the supported paths.
-//
-// entries is passed to reduce calls to ListEntries(), so
-// this has precondition:
-//
-//	entries == ctx.Repo.Commit.SubTree(ctx.Repo.TreePath).ListEntries()
-//
-// FIXME: There has to be a more efficient way of doing this
-func findReadmeFileInEntries(ctx *context.Context, entries []*git.TreeEntry, tryWellKnownDirs bool) (string, *git.TreeEntry, error) {
-	// Create a list of extensions in priority order
-	// 1. Markdown files - with and without localisation - e.g. README.en-us.md or README.md
-	// 2. Txt files - e.g. README.txt
-	// 3. No extension - e.g. README
-	exts := append(localizedExtensions(".md", ctx.Locale.Language()), ".txt", "") // sorted by priority
-	extCount := len(exts)
-	readmeFiles := make([]*git.TreeEntry, extCount+1)
-
-	docsEntries := make([]*git.TreeEntry, 3) // (one of docs/, .gitea/ or .github/)
-	for _, entry := range entries {
-		if tryWellKnownDirs && entry.IsDir() {
-			// as a special case for the top-level repo introduction README,
-			// fall back to subfolders, looking for e.g. docs/README.md, .gitea/README.zh-CN.txt, .github/README.txt, ...
-			// (note that docsEntries is ignored unless we are at the root)
-			lowerName := strings.ToLower(entry.Name())
-			switch lowerName {
-			case "docs":
-				if entry.Name() == "docs" || docsEntries[0] == nil {
-					docsEntries[0] = entry
-				}
-			case ".gitea":
-				if entry.Name() == ".gitea" || docsEntries[1] == nil {
-					docsEntries[1] = entry
-				}
-			case ".github":
-				if entry.Name() == ".github" || docsEntries[2] == nil {
-					docsEntries[2] = entry
-				}
-			}
-			continue
-		}
-		if i, ok := util.IsReadmeFileExtension(entry.Name(), exts...); ok {
-			log.Debug("Potential readme file: %s", entry.Name())
-			if readmeFiles[i] == nil || base.NaturalSortLess(readmeFiles[i].Name(), entry.Blob().Name()) {
-				if entry.IsLink() {
-					target, err := entry.FollowLinks()
-					if err != nil && !git.IsErrBadLink(err) {
-						return "", nil, err
-					} else if target != nil && (target.IsExecutable() || target.IsRegular()) {
-						readmeFiles[i] = entry
-					}
-				} else {
-					readmeFiles[i] = entry
-				}
-			}
-		}
-	}
-	var readmeFile *git.TreeEntry
-	for _, f := range readmeFiles {
-		if f != nil {
-			readmeFile = f
-			break
-		}
-	}
-
-	if ctx.Repo.TreePath == "" && readmeFile == nil {
-		for _, subTreeEntry := range docsEntries {
-			if subTreeEntry == nil {
-				continue
-			}
-			subTree := subTreeEntry.Tree()
-			if subTree == nil {
-				// this should be impossible; if subTreeEntry exists so should this.
-				continue
-			}
-			var err error
-			childEntries, err := subTree.ListEntries()
-			if err != nil {
-				return "", nil, err
-			}
-
-			subfolder, readmeFile, err := findReadmeFileInEntries(ctx, childEntries, false)
-			if err != nil && !git.IsErrNotExist(err) {
-				return "", nil, err
-			}
-			if readmeFile != nil {
-				return path.Join(subTreeEntry.Name(), subfolder), readmeFile, nil
-			}
-		}
-	}
-
-	return "", readmeFile, nil
-}
-
 func renderDirectory(ctx *context.Context, treeLink string) {
 	entries := renderDirectoryFiles(ctx, 1*time.Second)
 	if ctx.Written() {
@@ -159,176 +64,20 @@ func renderDirectory(ctx *context.Context, treeLink string) {
 		ctx.Data["Title"] = ctx.Tr("repo.file.title", ctx.Repo.Repository.Name+"/"+path.Base(ctx.Repo.TreePath), ctx.Repo.RefName)
 	}
 
-	subfolder, readmeFile, err := findReadmeFileInEntries(ctx, entries, true)
+	subfolder, readmeFile, err := render.FindReadmeFileInEntries(ctx, entries, true)
 	if err != nil {
 		ctx.ServerError("findReadmeFileInEntries", err)
 		return
 	}
 
-	renderReadmeFile(ctx, subfolder, readmeFile, treeLink)
-}
-
-// localizedExtensions prepends the provided language code with and without a
-// regional identifier to the provided extension.
-// Note: the language code will always be lower-cased, if a region is present it must be separated with a `-`
-// Note: ext should be prefixed with a `.`
-func localizedExtensions(ext, languageCode string) (localizedExts []string) {
-	if len(languageCode) < 1 {
-		return []string{ext}
-	}
-
-	lowerLangCode := "." + strings.ToLower(languageCode)
-
-	if strings.Contains(lowerLangCode, "-") {
-		underscoreLangCode := strings.ReplaceAll(lowerLangCode, "-", "_")
-		indexOfDash := strings.Index(lowerLangCode, "-")
-		// e.g. [.zh-cn.md, .zh_cn.md, .zh.md, _zh.md, .md]
-		return []string{lowerLangCode + ext, underscoreLangCode + ext, lowerLangCode[:indexOfDash] + ext, "_" + lowerLangCode[1:indexOfDash] + ext, ext}
-	}
-
-	// e.g. [.en.md, .md]
-	return []string{lowerLangCode + ext, ext}
-}
-
-type fileInfo struct {
-	isTextFile bool
-	isLFSFile  bool
-	fileSize   int64
-	lfsMeta    *lfs.Pointer
-	st         typesniffer.SniffedType
-}
-
-func getFileReader(repoID int64, blob *git.Blob) ([]byte, io.ReadCloser, *fileInfo, error) {
-	dataRc, err := blob.DataAsync()
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
-	buf := make([]byte, 1024)
-	n, _ := util.ReadAtMost(dataRc, buf)
-	buf = buf[:n]
-
-	st := typesniffer.DetectContentType(buf)
-	isTextFile := st.IsText()
-
-	// FIXME: what happens when README file is an image?
-	if !isTextFile || !setting.LFS.StartServer {
-		return buf, dataRc, &fileInfo{isTextFile, false, blob.Size(), nil, st}, nil
-	}
-
-	pointer, _ := lfs.ReadPointerFromBuffer(buf)
-	if !pointer.IsValid() { // fallback to plain file
-		return buf, dataRc, &fileInfo{isTextFile, false, blob.Size(), nil, st}, nil
-	}
-
-	meta, err := git_model.GetLFSMetaObjectByOid(db.DefaultContext, repoID, pointer.Oid)
-	if err != nil && err != git_model.ErrLFSObjectNotExist { // fallback to plain file
-		return buf, dataRc, &fileInfo{isTextFile, false, blob.Size(), nil, st}, nil
-	}
-
-	dataRc.Close()
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
-	dataRc, err = lfs.ReadMetaObject(pointer)
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
-	buf = make([]byte, 1024)
-	n, err = util.ReadAtMost(dataRc, buf)
-	if err != nil {
-		dataRc.Close()
-		return nil, nil, nil, err
-	}
-	buf = buf[:n]
-
-	st = typesniffer.DetectContentType(buf)
-
-	return buf, dataRc, &fileInfo{st.IsText(), true, meta.Size, &meta.Pointer, st}, nil
-}
-
-func renderReadmeFile(ctx *context.Context, subfolder string, readmeFile *git.TreeEntry, readmeTreelink string) {
-	target := readmeFile
-	if readmeFile != nil && readmeFile.IsLink() {
-		target, _ = readmeFile.FollowLinks()
-	}
-	if target == nil {
-		// if findReadmeFile() failed and/or gave us a broken symlink (which it shouldn't)
-		// simply skip rendering the README
-		return
-	}
-
-	ctx.Data["RawFileLink"] = ""
-	ctx.Data["ReadmeInList"] = true
-	ctx.Data["ReadmeExist"] = true
-	ctx.Data["FileIsSymlink"] = readmeFile.IsLink()
-
-	buf, dataRc, fInfo, err := getFileReader(ctx.Repo.Repository.ID, target.Blob())
-	if err != nil {
-		ctx.ServerError("getFileReader", err)
-		return
-	}
-	defer dataRc.Close()
-
-	ctx.Data["FileIsText"] = fInfo.isTextFile
-	ctx.Data["FileName"] = path.Join(subfolder, readmeFile.Name())
-	ctx.Data["IsLFSFile"] = fInfo.isLFSFile
-
-	if fInfo.isLFSFile {
-		filenameBase64 := base64.RawURLEncoding.EncodeToString([]byte(readmeFile.Name()))
-		ctx.Data["RawFileLink"] = fmt.Sprintf("%s.git/info/lfs/objects/%s/%s", ctx.Repo.Repository.Link(), url.PathEscape(fInfo.lfsMeta.Oid), url.PathEscape(filenameBase64))
-	}
-
-	if !fInfo.isTextFile {
-		return
-	}
-
-	if fInfo.fileSize >= setting.UI.MaxDisplayFileSize {
-		// Pretend that this is a normal text file to display 'This file is too large to be shown'
-		ctx.Data["IsFileTooLarge"] = true
-		ctx.Data["IsTextFile"] = true
-		ctx.Data["FileSize"] = fInfo.fileSize
-		return
-	}
-
-	rd := charset.ToUTF8WithFallbackReader(io.MultiReader(bytes.NewReader(buf), dataRc))
-
-	if markupType := markup.Type(readmeFile.Name()); markupType != "" {
-		ctx.Data["IsMarkup"] = true
-		ctx.Data["MarkupType"] = markupType
-
-		ctx.Data["EscapeStatus"], ctx.Data["FileContent"], err = markupRender(ctx, &markup.RenderContext{
-			Ctx:          ctx,
-			RelativePath: path.Join(ctx.Repo.TreePath, readmeFile.Name()), // ctx.Repo.TreePath is the directory not the Readme so we must append the Readme filename (and path).
-			URLPrefix:    path.Join(readmeTreelink, subfolder),
-			Metas:        ctx.Repo.Repository.ComposeDocumentMetas(),
-			GitRepo:      ctx.Repo.GitRepo,
-		}, rd)
-		if err != nil {
-			log.Error("Render failed for %s in %-v: %v Falling back to rendering source", readmeFile.Name(), ctx.Repo.Repository, err)
-			buf := &bytes.Buffer{}
-			ctx.Data["EscapeStatus"], _ = charset.EscapeControlStringReader(rd, buf, ctx.Locale)
-			ctx.Data["FileContent"] = buf.String()
-		}
-	} else {
-		ctx.Data["IsPlainText"] = true
-		buf := &bytes.Buffer{}
-		ctx.Data["EscapeStatus"], err = charset.EscapeControlStringReader(rd, buf, ctx.Locale)
-		if err != nil {
-			log.Error("Read failed: %v", err)
-		}
-
-		ctx.Data["FileContent"] = buf.String()
-	}
+	render.ReadmeFile(ctx, subfolder, readmeFile, treeLink)
 }
 
 func renderFile(ctx *context.Context, entry *git.TreeEntry, treeLink, rawLink string) {
 	ctx.Data["IsViewFile"] = true
 	ctx.Data["HideRepoInfo"] = true
 	blob := entry.Blob()
-	buf, dataRc, fInfo, err := getFileReader(ctx.Repo.Repository.ID, blob)
+	buf, dataRc, fInfo, err := render.GetFileReader(ctx.Repo.Repository.ID, blob)
 	if err != nil {
 		ctx.ServerError("getFileReader", err)
 		return
@@ -374,24 +123,24 @@ func renderFile(ctx *context.Context, entry *git.TreeEntry, treeLink, rawLink st
 	isDisplayingSource := ctx.FormString("display") == "source"
 	isDisplayingRendered := !isDisplayingSource
 
-	if fInfo.isLFSFile {
+	if fInfo.IsLFSFile() {
 		ctx.Data["RawFileLink"] = ctx.Repo.RepoLink + "/media/" + ctx.Repo.BranchNameSubURL() + "/" + util.PathEscapeSegments(ctx.Repo.TreePath)
 	}
 
-	isRepresentableAsText := fInfo.st.IsRepresentableAsText()
+	isRepresentableAsText := fInfo.St.IsRepresentableAsText()
 	if !isRepresentableAsText {
 		// If we can't show plain text, always try to render.
 		isDisplayingSource = false
 		isDisplayingRendered = true
 	}
-	ctx.Data["IsLFSFile"] = fInfo.isLFSFile
-	ctx.Data["FileSize"] = fInfo.fileSize
-	ctx.Data["IsTextFile"] = fInfo.isTextFile
+	ctx.Data["IsLFSFile"] = fInfo.IsLFSFile()
+	ctx.Data["FileSize"] = fInfo.FileSize()
+	ctx.Data["IsTextFile"] = fInfo.IsTextFile()
 	ctx.Data["IsRepresentableAsText"] = isRepresentableAsText
 	ctx.Data["IsDisplayingSource"] = isDisplayingSource
 	ctx.Data["IsDisplayingRendered"] = isDisplayingRendered
 
-	isTextSource := fInfo.isTextFile || isDisplayingSource
+	isTextSource := fInfo.IsTextFile() || isDisplayingSource
 	ctx.Data["IsTextSource"] = isTextSource
 	if isTextSource {
 		ctx.Data["CanCopyContent"] = true
@@ -416,7 +165,7 @@ func renderFile(ctx *context.Context, entry *git.TreeEntry, treeLink, rawLink st
 	}
 
 	// Assume file is not editable first.
-	if fInfo.isLFSFile {
+	if fInfo.IsLFSFile() {
 		ctx.Data["EditFileTooltip"] = ctx.Tr("repo.editor.cannot_edit_lfs_files")
 	} else if !isRepresentableAsText {
 		ctx.Data["EditFileTooltip"] = ctx.Tr("repo.editor.cannot_edit_non_text_files")
@@ -424,13 +173,13 @@ func renderFile(ctx *context.Context, entry *git.TreeEntry, treeLink, rawLink st
 
 	switch {
 	case isRepresentableAsText:
-		if fInfo.st.IsSvgImage() {
+		if fInfo.St.IsSvgImage() {
 			ctx.Data["IsImageFile"] = true
 			ctx.Data["CanCopyContent"] = true
 			ctx.Data["HasSourceRenderedToggle"] = true
 		}
 
-		if fInfo.fileSize >= setting.UI.MaxDisplayFileSize {
+		if fInfo.FileSize() >= setting.UI.MaxDisplayFileSize {
 			ctx.Data["IsFileTooLarge"] = true
 			break
 		}
@@ -461,7 +210,7 @@ func renderFile(ctx *context.Context, entry *git.TreeEntry, treeLink, rawLink st
 			}
 			metas := ctx.Repo.Repository.ComposeDocumentMetas()
 			metas["BranchNameSubURL"] = ctx.Repo.BranchNameSubURL()
-			ctx.Data["EscapeStatus"], ctx.Data["FileContent"], err = markupRender(ctx, &markup.RenderContext{
+			ctx.Data["EscapeStatus"], ctx.Data["FileContent"], err = render.MarkupRender(ctx, &markup.RenderContext{
 				Ctx:          ctx,
 				Type:         markupType,
 				RelativePath: ctx.Repo.TreePath,
@@ -528,7 +277,7 @@ func renderFile(ctx *context.Context, entry *git.TreeEntry, treeLink, rawLink st
 			ctx.Data["FileContent"] = fileContent
 			ctx.Data["LineEscapeStatus"] = statuses
 		}
-		if !fInfo.isLFSFile {
+		if !fInfo.IsLFSFile() {
 			if ctx.Repo.CanEnableEditor(ctx.Doer) {
 				if lfsLock != nil && lfsLock.OwnerID != ctx.Doer.ID {
 					ctx.Data["CanEditFile"] = false
@@ -544,17 +293,17 @@ func renderFile(ctx *context.Context, entry *git.TreeEntry, treeLink, rawLink st
 			}
 		}
 
-	case fInfo.st.IsPDF():
+	case fInfo.St.IsPDF():
 		ctx.Data["IsPDFFile"] = true
-	case fInfo.st.IsVideo():
+	case fInfo.St.IsVideo():
 		ctx.Data["IsVideoFile"] = true
-	case fInfo.st.IsAudio():
+	case fInfo.St.IsAudio():
 		ctx.Data["IsAudioFile"] = true
-	case fInfo.st.IsImage() && (setting.UI.SVG.Enabled || !fInfo.st.IsSvgImage()):
+	case fInfo.St.IsImage() && (setting.UI.SVG.Enabled || !fInfo.St.IsSvgImage()):
 		ctx.Data["IsImageFile"] = true
 		ctx.Data["CanCopyContent"] = true
 	default:
-		if fInfo.fileSize >= setting.UI.MaxDisplayFileSize {
+		if fInfo.FileSize() >= setting.UI.MaxDisplayFileSize {
 			ctx.Data["IsFileTooLarge"] = true
 			break
 		}
@@ -563,7 +312,7 @@ func renderFile(ctx *context.Context, entry *git.TreeEntry, treeLink, rawLink st
 			rd := io.MultiReader(bytes.NewReader(buf), dataRc)
 			ctx.Data["IsMarkup"] = true
 			ctx.Data["MarkupType"] = markupType
-			ctx.Data["EscapeStatus"], ctx.Data["FileContent"], err = markupRender(ctx, &markup.RenderContext{
+			ctx.Data["EscapeStatus"], ctx.Data["FileContent"], err = render.MarkupRender(ctx, &markup.RenderContext{
 				Ctx:          ctx,
 				RelativePath: ctx.Repo.TreePath,
 				URLPrefix:    path.Dir(treeLink),
@@ -592,23 +341,6 @@ func renderFile(ctx *context.Context, entry *git.TreeEntry, treeLink, rawLink st
 	}
 }
 
-func markupRender(ctx *context.Context, renderCtx *markup.RenderContext, input io.Reader) (escaped *charset.EscapeStatus, output string, err error) {
-	markupRd, markupWr := io.Pipe()
-	defer markupWr.Close()
-	done := make(chan struct{})
-	go func() {
-		sb := &strings.Builder{}
-		// We allow NBSP here this is rendered
-		escaped, _ = charset.EscapeControlReader(markupRd, sb, ctx.Locale, charset.RuneNBSP)
-		output = sb.String()
-		close(done)
-	}()
-	err = markup.Render(renderCtx, input, markupWr)
-	_ = markupWr.CloseWithError(err)
-	<-done
-	return escaped, output, err
-}
-
 func safeURL(address string) string {
 	u, err := url.Parse(address)
 	if err != nil {
diff --git a/routers/web/shared/user/header.go b/routers/web/shared/user/header.go
index 9594e6975a8ef..2ac57630af7c0 100644
--- a/routers/web/shared/user/header.go
+++ b/routers/web/shared/user/header.go
@@ -4,10 +4,13 @@
 package user
 
 import (
-	repo_model "code.gitea.io/gitea/models/repo"
+	"errors"
+
 	"code.gitea.io/gitea/modules/context"
-	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/setting"
+	"code.gitea.io/gitea/routers/web/repo/render"
+	"code.gitea.io/gitea/services/user"
 )
 
 func RenderUserHeader(ctx *context.Context) {
@@ -17,22 +20,36 @@ func RenderUserHeader(ctx *context.Context) {
 	ctx.Data["ContextUser"] = ctx.ContextUser
 	tab := ctx.FormString("tab")
 	ctx.Data["TabName"] = tab
-	repo, err := repo_model.GetRepositoryByName(ctx.ContextUser.ID, ".profile")
-	if err == nil && !repo.IsEmpty {
-		gitRepo, err := git.OpenRepository(ctx, repo.RepoPath())
-		if err != nil {
-			ctx.ServerError("OpenRepository", err)
-			return
-		}
-		defer gitRepo.Close()
-		commit, err := gitRepo.GetBranchCommit(repo.DefaultBranch)
-		if err != nil {
-			ctx.ServerError("GetBranchCommit", err)
-			return
-		}
-		blob, err := commit.GetBlobByPath("README.md")
-		if err == nil && blob != nil {
-			ctx.Data["ProfileReadme"] = true
+
+	repo, gitRepo, err := user.OpenUserProfileRepo(ctx, ctx.ContextUser)
+	if err != nil {
+		if !errors.Is(err, user.ErrProfileRepoNotExist) {
+			log.Error("OpenUserProfileRepo: %v", err)
 		}
+		return
+	}
+	defer gitRepo.Close()
+
+	commit, err := gitRepo.GetBranchCommit(repo.DefaultBranch)
+	if err != nil {
+		log.Error("GetBranchCommit: %v", err)
+		return
+	}
+	entry, err := commit.SubTree("/")
+	if err != nil {
+		log.Error("GetBranchCommit: %v", err)
+		return
+	}
+	allEntrys, err := entry.ListEntries()
+	if err != nil {
+		log.Error("entry.Tree().ListEntries: %v", err)
+		return
 	}
+	_, readmeFile, err := render.FindReadmeFileInEntries(ctx, allEntrys, true)
+	if err != nil {
+		log.Error("FindReadmeFileInEntries: %v", err)
+		return
+	}
+
+	ctx.Data["ProfileReadme"] = readmeFile != nil
 }
diff --git a/routers/web/user/profile.go b/routers/web/user/profile.go
index 6f9f84d60dbdf..60285d5d55b36 100644
--- a/routers/web/user/profile.go
+++ b/routers/web/user/profile.go
@@ -5,8 +5,10 @@
 package user
 
 import (
+	"errors"
 	"fmt"
 	"net/http"
+	"path"
 	"strings"
 
 	activities_model "code.gitea.io/gitea/models/activities"
@@ -16,13 +18,15 @@ import (
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/context"
-	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/markup"
 	"code.gitea.io/gitea/modules/markup/markdown"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/util"
 	"code.gitea.io/gitea/routers/web/feed"
 	"code.gitea.io/gitea/routers/web/org"
+	"code.gitea.io/gitea/routers/web/repo/render"
+	"code.gitea.io/gitea/services/user"
 )
 
 // Profile render user's profile page
@@ -92,37 +96,7 @@ func Profile(ctx *context.Context) {
 		ctx.Data["RenderedDescription"] = content
 	}
 
-	repo, err := repo_model.GetRepositoryByName(ctx.ContextUser.ID, ".profile")
-	if err == nil && !repo.IsEmpty {
-		gitRepo, err := git.OpenRepository(ctx, repo.RepoPath())
-		if err != nil {
-			ctx.ServerError("OpenRepository", err)
-			return
-		}
-		defer gitRepo.Close()
-		commit, err := gitRepo.GetBranchCommit(repo.DefaultBranch)
-		if err != nil {
-			ctx.ServerError("GetBranchCommit", err)
-			return
-		}
-		blob, err := commit.GetBlobByPath("README.md")
-		if err == nil {
-			bytes, err := blob.GetBlobContent(setting.UI.MaxDisplayFileSize)
-			if err != nil {
-				ctx.ServerError("GetBlobContent", err)
-				return
-			}
-			profileContent, err := markdown.RenderString(&markup.RenderContext{
-				Ctx:     ctx,
-				GitRepo: gitRepo,
-			}, bytes)
-			if err != nil {
-				ctx.ServerError("RenderString", err)
-				return
-			}
-			ctx.Data["ProfileReadme"] = profileContent
-		}
-	}
+	renderProfileReadme(ctx)
 
 	showPrivate := ctx.IsSigned && (ctx.Doer.IsAdmin || ctx.Doer.ID == ctx.ContextUser.ID)
 
@@ -365,3 +339,49 @@ func Action(ctx *context.Context) {
 	// FIXME: We should check this URL and make sure that it's a valid Gitea URL
 	ctx.RedirectToFirst(ctx.FormString("redirect_to"), ctx.ContextUser.HomeLink())
 }
+
+func renderProfileReadme(ctx *context.Context) {
+	repo, gitRepo, err := user.OpenUserProfileRepo(ctx, ctx.ContextUser)
+	if err != nil {
+		if !errors.Is(err, user.ErrProfileRepoNotExist) {
+			log.Error("OpenUserProfileRepo: %v", err)
+		}
+
+		return
+	}
+
+	commit, err := gitRepo.GetBranchCommit(repo.DefaultBranch)
+	if err != nil {
+		log.Error("GetBranchCommit: %v", err)
+		return
+	}
+	entry, err := commit.SubTree("/")
+	if err != nil {
+		log.Error("GetBranchCommit: %v", err)
+		return
+	}
+	allEntrys, err := entry.ListEntries()
+	if err != nil {
+		log.Error("entry.Tree().ListEntries: %v", err)
+		return
+	}
+	subfolder, readmeFile, err := render.FindReadmeFileInEntries(ctx, allEntrys, true)
+	if err != nil {
+		log.Error("FindReadmeFileInEntries: %v", err)
+		return
+	}
+
+	ctx.Repo = &context.Repository{
+		GitRepo:    gitRepo,
+		Repository: repo,
+		TreePath:   "/",
+	}
+	render.ReadmeFile(ctx, subfolder, readmeFile, repo.Link()+"/src/branch/"+repo.DefaultBranch)
+	if !ctx.Written() {
+		ctx.Data["ProfileReadme"] = true
+	}
+
+	if fileName, ok := ctx.Data["FileName"].(string); ok {
+		ctx.Data["FileName"] = path.Join(repo.Name, fileName)
+	}
+}
diff --git a/routers/web/user/setting/profile.go b/routers/web/user/setting/profile.go
index 47066d5e384ef..bbb1a26cbcde1 100644
--- a/routers/web/user/setting/profile.go
+++ b/routers/web/user/setting/profile.go
@@ -39,10 +39,12 @@ const (
 )
 
 // Profile render user's profile page
+// .....
 func Profile(ctx *context.Context) {
 	ctx.Data["Title"] = ctx.Tr("settings.profile")
 	ctx.Data["PageIsSettingsProfile"] = true
 	ctx.Data["AllowedUserVisibilityModes"] = setting.Service.AllowedUserVisibilityModesSlice.ToVisibleTypeSlice()
+	ctx.Data["ProfileRepoName"], _ = user_model.GetUserSetting(ctx.Doer.ID, user_model.SettingsKeyProfileRepoName)
 
 	ctx.HTML(http.StatusOK, tplSettingsProfile)
 }
@@ -116,6 +118,11 @@ func ProfilePost(ctx *context.Context) {
 		return
 	}
 
+	if err := user_model.SetUserSetting(ctx.Doer.ID, user_model.SettingsKeyProfileRepoName, form.ProfileRepoName); err != nil {
+		ctx.ServerError("SetUserSetting", err)
+		return
+	}
+
 	log.Trace("User settings updated: %s", ctx.Doer.Name)
 	ctx.Flash.Success(ctx.Tr("settings.update_profile_success"))
 	ctx.Redirect(setting.AppSubURL + "/user/settings")
diff --git a/services/convert/user.go b/services/convert/user.go
index 79fcba0176f9a..3660753e240ee 100644
--- a/services/convert/user.go
+++ b/services/convert/user.go
@@ -85,7 +85,7 @@ func toUser(ctx context.Context, user *user_model.User, signed, authed bool) *ap
 
 // User2UserSettings return UserSettings based on a user
 func User2UserSettings(user *user_model.User) api.UserSettings {
-	return api.UserSettings{
+	settings := api.UserSettings{
 		FullName:      user.FullName,
 		Website:       user.Website,
 		Location:      user.Location,
@@ -96,6 +96,13 @@ func User2UserSettings(user *user_model.User) api.UserSettings {
 		HideActivity:  user.KeepActivityPrivate,
 		DiffViewStyle: user.DiffViewStyle,
 	}
+
+	settings.ProfileRepoName, _ = user_model.GetSetting(user.ID, user_model.SettingsKeyProfileRepoName)
+	if len(settings.ProfileRepoName) == 0 {
+		settings.ProfileRepoName = ".profile"
+	}
+
+	return settings
 }
 
 // ToUserAndPermission return User and its collaboration permission for a repository
diff --git a/services/forms/user_form.go b/services/forms/user_form.go
index 1315fb237b3bb..a270accd56d34 100644
--- a/services/forms/user_form.go
+++ b/services/forms/user_form.go
@@ -249,6 +249,7 @@ type UpdateProfileForm struct {
 	Description         string `binding:"MaxSize(255)"`
 	Visibility          structs.VisibleType
 	KeepActivityPrivate bool
+	ProfileRepoName     string
 }
 
 // Validate validates the fields
diff --git a/services/user/user.go b/services/user/user.go
index e0815bd860791..37adc857eec32 100644
--- a/services/user/user.go
+++ b/services/user/user.go
@@ -5,6 +5,7 @@ package user
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"strings"
@@ -19,6 +20,7 @@ import (
 	system_model "code.gitea.io/gitea/models/system"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/eventsource"
+	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/storage"
@@ -317,3 +319,31 @@ func DeleteInactiveUsers(ctx context.Context, olderThan time.Duration) error {
 
 	return user_model.DeleteInactiveEmailAddresses(ctx)
 }
+
+var ErrProfileRepoNotExist = errors.New("profile repo not exist")
+
+// OpenUserProfileRepo open profile repo for a user
+func OpenUserProfileRepo(ctx context.Context, user *user_model.User) (*repo_model.Repository, *git.Repository, error) {
+	repoName, err := user_model.GetSetting(user.ID, user_model.SettingsKeyProfileRepoName)
+	if err != nil && !errors.Is(err, util.ErrNotExist) {
+		return nil, nil, err
+	}
+	if len(repoName) == 0 {
+		repoName = ".profile"
+	}
+
+	repo, err := repo_model.GetRepositoryByName(user.ID, repoName)
+	if err != nil && !repo_model.IsErrRepoNotExist(err) {
+		return nil, nil, err
+	}
+	if repo == nil || repo.IsEmpty {
+		return nil, nil, ErrProfileRepoNotExist
+	}
+
+	gitRepo, err := git.OpenRepository(ctx, repo.RepoPath())
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return repo, gitRepo, nil
+}
diff --git a/templates/swagger/v1_json.tmpl b/templates/swagger/v1_json.tmpl
index e78c077fc3b32..02c91357d34c7 100644
--- a/templates/swagger/v1_json.tmpl
+++ b/templates/swagger/v1_json.tmpl
@@ -21706,6 +21706,10 @@
           "type": "string",
           "x-go-name": "Location"
         },
+        "profile_repo_name": {
+          "type": "string",
+          "x-go-name": "ProfileRepoName"
+        },
         "theme": {
           "type": "string",
           "x-go-name": "Theme"
@@ -21750,6 +21754,10 @@
           "type": "string",
           "x-go-name": "Location"
         },
+        "profile_repo_name": {
+          "type": "string",
+          "x-go-name": "ProfileRepoName"
+        },
         "theme": {
           "type": "string",
           "x-go-name": "Theme"
diff --git a/templates/user/profile.tmpl b/templates/user/profile.tmpl
index 51d4a46a928d7..faa0f59bb00fe 100644
--- a/templates/user/profile.tmpl
+++ b/templates/user/profile.tmpl
@@ -150,7 +150,7 @@
 					{{template "explore/repo_list" .}}
 					{{template "base/paginate" .}}
 				{{else if .ProfileReadme}}
-					<div id="readme_profile" class="render-content markup"> {{$.ProfileReadme|Str2html}} </div>
+					{{template "repo/view_file" .}}
 				{{end}}
 			</div>
 		</div>
diff --git a/templates/user/settings/profile.tmpl b/templates/user/settings/profile.tmpl
index a581b13bd57fc..e7650452392f6 100644
--- a/templates/user/settings/profile.tmpl
+++ b/templates/user/settings/profile.tmpl
@@ -43,6 +43,10 @@
 					<label for="location">{{.locale.Tr "settings.location"}}</label>
 					<input id="location" name="location"  value="{{.SignedUser.Location}}" maxlength="50">
 				</div>
+				<div class="field">
+					<label for="profile_repo_name">{{.locale.Tr "settings.profile_repo_name"}}</label>
+					<input id="profile_repo_name" name="profile_repo_name"  value="{{.ProfileRepoName}}" placeholder=".profile">
+				</div>
 
 				<div class="ui divider"></div>
 				<!-- private block -->