Undergraduate Universities

Explore UK universities below or take our new Find Your UK University Quiz to quickly find the best matches for you!

Search Undergraduate Universities

Academic matches are based on minimum US entry requirements.

At BIMM University we provide an extensive range of courses in modern music, performing arts, and filmmaking to over 9,000 students across 15 campuses and colleges in the UK, Germany and Ireland. As a student at BIMM University, you will join a real community of creatives, with opportunities to collaborate across its disciplines both inside and outside of the classroom. 

{"map_options":{"center_lat":"55.9106215","center_lng":"-3.3166116","zoom":5,"map_type_id":"ROADMAP","center_by_nearest":false,"fit_bounds":true,"center_circle_fillcolor":"#8CAEF2","center_circle_strokecolor":"#8CAEF2","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https://www.wpleaflet.com/wp-content/plugins/wp-leaflet-maps-pro/assets/images//default_marker.png","draggable":true,"scroll_wheel":"false","gesture":"auto","marker_default_icon":"https://theukstudyexpert.com/wp-content/plugins/wp-google-map-gold/assets/images/icons/marker_default_icon.png","infowindow_setting":"<div class=\"fc-item-box fc-item-no-padding\">\n    {marker_image}</p>\n<div class=\"fc-itemcontent-padding\">\n<div class=\"fc-item-padding-content_20\">\n<div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">{marker_category}</div>\n<div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{marker_title}</div>\n<div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\n                {marker_message}<br />\n<strong>Course - </strong> {course}<br />\n<strong>Type of College - </strong> {type-of-college}<br />\n<strong>Program Type - </strong> {program-type}\n            </div>\n</p></div>\n</p></div>\n</div>\n","infowindow_geotags_setting":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    {post_featured_image}\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"{post_link}\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{post_title}</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                {post_excerpt}\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","infowindow_skin":{"name":"udine","type":"infowindow","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    {marker_image}\r\n    &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n        &lt;div class=&quot;fc-item-padding-content_20&quot;&gt;\r\n            &lt;div class=&quot;fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center&quot;&gt;{marker_category}&lt;/div&gt;\r\n            &lt;div class=&quot;fc-item-title fc-item-primary-text-color fc-text-center&quot;&gt;{marker_title}&lt;/div&gt;\r\n            &lt;div class=&quot;fc-item-content fc-item-body-text-color fc-item-top-space&quot;&gt;\r\n                {marker_message}&lt;br&gt;\r\n&lt;strong&gt;Course - &lt;/strong&gt; {course}&lt;br&gt;\r\n&lt;strong&gt;Type of College - &lt;/strong&gt; {type-of-college}&lt;br&gt;\r\n&lt;strong&gt;Program Type - &lt;/strong&gt; {program-type}\r\n            &lt;/div&gt;\r\n\r\n        &lt;/div&gt;\r\n    &lt;/div&gt;\r\n&lt;/div&gt;"},"infowindow_post_skin":{"name":"udine","type":"post","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    {post_featured_image}\r\n    &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n        &lt;div class=&quot;fc-item-padding-content_20&quot;&gt;\r\n&lt;a href=&quot;{post_link}&quot; class=&quot;fc-item-title fc-item-primary-text-color fc-text-center&quot;&gt;{post_title}&lt;/a&gt;\r\n            &lt;div class=&quot;fc-item-content fc-item-body-text-color fc-item-top-space&quot;&gt;\r\n                {post_excerpt}\r\n            &lt;/div&gt;\r\n        &lt;/div&gt;\r\n    &lt;/div&gt;\r\n&lt;/div&gt;"},"infowindow_drop_animation":true,"close_infowindow_on_map_click":true,"default_infowindow_open":false,"infowindow_open_event":"click","listing_infowindow_open_event":"click","is_mobile":false,"infowindow_filter_only":false,"infowindow_click_change_zoom":0,"infowindow_click_change_center":true,"full_screen_control":true,"search_control":true,"exclude_fields":["{%_custom_priority_meta_key%}","{post_featured_image}","{post_link}"],"zoom_control":true,"map_type_control":true,"street_view_control":true,"locateme_control":true,"mobile_specific":false,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"BOTTOM_LEFT","search_control_position":"BOTTOM_LEFT","locateme_control_position":"BOTTOM_LEFT","zoom_control_position":"LEFT_BOTTOM","map_type_control_position":"BOTTOM_LEFT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"BOTTOM_LEFT","map_control":false,"screens":{"smartphones":{"map_zoom_level_mobile":"5"},"ipads":{"map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":false,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#fff","show_infowindow_header":false,"min_zoom":"0","max_zoom":"19","zoom_level_after_search":"5","url_filters":true,"doubleclickzoom":true,"current_post_only":false,"search_placeholder":"Enter a search term (i.e. degree interest, city, country, etc.)...","bound_map_after_filter":true,"display_reset_button":false,"map_reset_button_text":"Reset","height":"650"},"places":[{"source":"post","title":"Heriot-Watt University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Heriot Watt University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/Heriot-Watt-logo-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/heriot-watt-university/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Heriot-Watt University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Heriot-Watt University is valued for its pioneering research, informed by the global needs of business and industry. We are specialists in business, engineering, design and the physical, social and life sciences.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Heriot-Watt University is valued for its pioneering research, informed by the global needs of business and industry. We are specialists in business, engineering, design and the physical, social and life sciences.","address":"The Avenue, Currie EH14 4AS, UK","location":{"lat":"55.9106215","state":"Scotland","country":"United Kingdom","lng":"-3.3166116","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/heriot-watt-university/","zoom":5,"extra_fields":{"post_excerpt":"Heriot-Watt University is valued for its pioneering research, informed by the global needs of business and industry. We are specialists in business, engineering, design and the physical, social and life sciences.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/Hariot-Watt-University.png\" alt=\"Heriot Watt University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/Hariot-Watt-University-1.png\" alt=\"Heriot Watt University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/Hariot-Watt-University-2.png\" alt=\"Heriot Watt University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/Hariot-Watt-University-3.png\" alt=\"Heriot Watt University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/Hariot-Watt-University-4.png\" alt=\"Heriot Watt University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/Hariot-Watt-University-5.png\" alt=\"Heriot Watt University\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact Heriot-Watt University\r\n</a>\r\n\r\n<strong>Location:</strong> The Avenue, Edinburgh, EH14 4AS\r\n\r\n<strong>Website:</strong> <a href=\"https://www.hw.ac.uk/\">https://www.hw.ac.uk/</a>\r\n<h3>Overview</h3>\r\nHeriot-Watt University is valued for its pioneering research, informed by the global needs of business and industry. With a rich heritage stretching back to 1821, we are a truly global university bringing together scholars who are leaders in ideas and solutions delivering innovation, educational excellence and ground-breaking research.\r\n\r\nWe are specialists in business, engineering, design and the physical, social and life sciences \u2013 subjects which make a real impact on the world and society.\r\n\r\nWith our roots in Scotland, our ambition and reach are truly international. We are a global university with around 27,000 students, five campuses and over 100 learning partners around the world. We are one of Scotland\u2019s most international universities; around a third of Heriot-Watt students in Edinburgh are from outside the UK.\r\n\r\nOur campuses are based in some of the world\u2019s most inspiring locations in the UK, Dubai and Malaysia. Each offers superb facilities, safe surroundings and an international welcome. We have built connected and integrated learning environments close to the vibrant cities of Edinburgh, Dubai and Kuala Lumpur.\r\n\r\n<strong>Population: </strong>27,000\r\n\r\n<strong>Campus Type: </strong>Suburban\r\n<h3>Quick Facts</h3>\r\n<ul>\r\n \t<li>Our heritage dates back to 1821.</li>\r\n \t<li>We are ranked 256th in the world, 32nd in the UK and 5th in Scotland. QS World University Rankings 2025.</li>\r\n \t<li>We are 1st in Scotland and 2nd in the UK for undergraduate employability. Graduate Outcomes Survey 2024.</li>\r\n \t<li>Ranked 1st in the UK for producing CEOs, MDs and Entrepreneurs. Novuna 2023.</li>\r\n \t<li>86% of our research outputs are ranked world-leading and internationally excellent. Research Excellence Framework 2021.</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://www.youtube.com/watch?v=DLcnVOjH_GQhttps://www.youtube.com/watch?v=QqASovgceREhttps://www.youtube.com/watch?v=xteSvbHys98&amp;list=PLN38FO_3p5OSavNSwfhqnMTNS9MdIesWl&amp;index=16https://www.youtube.com/watch?v=c8xsplOeTJohttps://www.youtube.com/watch?v=_Fm8-CZE-OQ&amp;list=PLN38FO_3p5OSwarz_sChSSpsswCbYZTd4https://www.youtube.com/watch?v=gWh89xNdl_U\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nWe normally require US applicants to hold a combination of the following qualifications for entry: as a minimum, applicants must hold an accredited high school diploma with a minimum GPA of 3.0 (on a 4.0 scale, minimum B average), and one letter of reference.\r\n\r\nIf submitting test scores, we ask for any of the following:\r\n<ul>\r\n \t<li>ACT composite score of 26 or above (with no individual section below 24)</li>\r\n \t<li>SAT (reading + mathematics) combined score of 1200 (with no individual score under 550); or SAT subjects tests at a score of 600 or higher</li>\r\n \t<li>Two AP tests at grade 4 or above (taken in junior or senior year of high school)</li>\r\n</ul>\r\nIf standardised test scores are unavailable, our admissions team will review your high school transcript and look for strong academic performance overall and in related subjects.\r\n\r\nThese entry requirements are meant to serve as a guide and do not guarantee entry onto a Heriot-Watt University degree programme.\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n<a href=\"https://www.hw.ac.uk/study/apply/uk/undergraduate.htm\" target=\"_blank\" rel=\"noopener\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nFor most of our masters-level programmes, we require a good first degree with a GPA of 3.0 out of 4.0 (or equivalent) or above in a relevant subject.\r\n\r\nFor PhD study, a masters-level qualification from a good university is normally required. Applicants should also demonstrate some form of research experience.\r\n\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n<a href=\"https://www.hw.ac.uk/study/apply/uk/postgraduate.htm\" target=\"_blank\" rel=\"noopener\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/HeriotWattUni/\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://x.com/HeriotWattUni?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor\" target=\"_blank\" rel=\"noopener\">\r\nTwitter\r\n</a>\r\n<a href=\"https://www.instagram.com/heriotwattuni/?hl=en\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/@HeriotWattUni\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.hw.ac.uk\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.hw.ac.uk/study/international-students.htm\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.hw.ac.uk/study/fees-and-funding/tuition-fees\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.hw.ac.uk/study/fees-and-funding/scholarships-and-bursaries\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.hw.ac.uk/study/fees-and-funding/financial-support/us-federal-loans\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.hw.ac.uk/visit-us/online-events-and-webinars\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.hw.ac.uk/research.htm\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.hw.ac.uk/uk/edinburgh/accommodation.htm\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.hw.ac.uk/uk/students/careers.htm\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.hwunion.com/get-involved/societies/\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"https://www.hw.ac.uk/study/how-to-apply.htm\" target=\"_blank\" rel=\"noopener\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"Heriot-Watt University","post_link":"https://theukstudyexpert.com/universities/heriot-watt-university/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Heriot Watt University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/Heriot-Watt-logo-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"Business Economics, Creativeperforming Arts Design, Engineering, Humanities, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"4","taxonomy=category":"Universities","taxonomy=post_tag":"Business Economics, Creativeperforming Arts Design, Engineering, Humanities, Social Science, Technology Computer Science","city_country":"Edinburgh, Scotland"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":18073,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Liverpool Hope University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Liverpool Hope University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/LHU-logo-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/liverpool-hope-university/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Liverpool Hope University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Liverpool Hope University combines top-ranked student satisfaction with beautiful campuses and vibrant city access, with over \u00a360 million invested in state-of-the-art facilities for an enriched learning environment.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Liverpool Hope University combines top-ranked student satisfaction with beautiful campuses and vibrant city access, with over \u00a360 million invested in state-of-the-art facilities for an enriched learning environment.","address":"Hope Park Sports, Liverpool L16 9JQ, UK","location":{"lat":"53.3910057","state":"England","country":"United Kingdom","lng":"-2.889647","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/liverpool-hope-university/","zoom":5,"extra_fields":{"post_excerpt":"Liverpool Hope University combines top-ranked student satisfaction with beautiful campuses and vibrant city access, with over \u00a360 million invested in state-of-the-art facilities for an enriched learning environment.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/Untitled-design-10.png\" alt=\"Liverpool Hope University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/HCA-Buildings.png\" alt=\"Liverpool Hope University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/Library-and-Study-Space.png\" alt=\"Liverpool Hope University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/Students-at-Creative-Campus.png\" alt=\"Liverpool Hope University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/Three-Graces-at-Liverpool.png\" alt=\"Liverpool Hope University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/World-Museum-and-Walker-Art-Gallery.png\" alt=\"Liverpool Hope University\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact Liverpool Hope University\r\n</a>\r\n\r\n<strong>Location:\u00a0</strong>Hope Park, Taggart Avenue, Childwall, Liverpool, Merseyside, L3 9PA\r\n\r\n<strong>Website:</strong> <a href=\"https://www.hope.ac.uk/\">https://www.hope.ac.uk/</a>\r\n<h3>Overview</h3>\r\nStudents at Liverpool Hope University have the best of both worlds; living and studying on friendly, beautiful campuses while also having the advantage of being a bus ride away from one of Europe\u2019s most vibrant and culturally rich cities.\r\n\r\nDating back to 1844, our students always benefit from a high-quality teaching and research environment. In 2023, we were proud to be awarded Silver in the Government\u2019s Teaching Excellence Framework (TEF).\r\n\r\nLiverpool Hope University is spread across two beautifully landscaped sites. Hope Park is located in the leafy suburbs of Liverpool, while our Creative Campus sits a stone\u2019s throw away from Liverpool's creative and cultural hubs and the buzz of a busy city centre. We have invested more than \u00a360 million in new university buildings and facilities to support the creation of an enriched learning environment.\r\n\r\nOur students are at the heart of our university, demonstrated by our Top 3 ranking for Student Satisfaction in the North West. (Complete University Guide 2024)\r\nLiverpool, a city like no other, boasts world-famous architecture, magnificent museums, and a rich musical heritage that has shaped popular culture. This vibrant hub of creativity hosts spectacular festivals, thrilling sporting events, and unique art, consistently drawing millions of visitors each year. It's no wonder that Liverpool was recognized as one of Britain's top travel destinations (Telegraph, 2018).\r\n\r\n<strong>Population: </strong>5,261\r\n\r\n<strong>Campus Type: </strong>Suburban\r\n<h3>Quick Facts</h3>\r\n<ul>\r\n \t<li>Ranked 5th in the UK for Student Satisfaction (Times Higher Education analysis of the National Student Survey 2024)</li>\r\n \t<li>Ranked 1st in the North West for Education (The Guardian University Guide 2024)</li>\r\n \t<li>Ranked 3rd in the North West and joint 27th in the UK for Student Satisfaction (The Complete University Guide 2024)</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://www.youtube.com/watch?v=qdieMCBlPe8&amp;t=8shttps://www.youtube.com/watch?v=GOFxVuYynqM&amp;t=34shttps://www.youtube.com/watch?v=dgRhQGzh9Yghttps://www.youtube.com/watch?v=vbSv_pgd28Ehttps://www.youtube.com/watch?v=DOunwXqbij0\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nYou should have a High School Diploma (Grade 12) with a GPA of 3.0 or above\r\nwith one of the following:\r\n<ul>\r\n \t<li>3 Advanced Placement Exams at grade 3 or above</li>\r\n \t<li>ACT with minimum score of 26</li>\r\n \t<li>SATR score of 1200 including a minimum of 600 in Reading and Writing, and 600 in Maths</li>\r\n \t<li>Associate Degree with a GPA of 3.0</li>\r\n</ul>\r\nWe will also consider one years study at an American University.\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n<ul>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance and Business Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance and Business Management (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance and Computer Science</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance and Computer Science (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance and Economics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance and Economics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance and Information Technology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance and Information Technology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance and Law</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting and Finance and Law (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance and Mathematics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance and Mathematics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance and Sport &amp; Physical Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Accounting &amp; Finance and Sport &amp; Physical Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Contemporary Fashion Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Contemporary Fashion Design (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Creative Writing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Creative Writing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Digital Creativity</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Digital Creativity (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Drama</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Drama (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and English Language</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and English Language (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Film &amp; Visual Culture</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Film &amp; Visual Culture (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and International Relations</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and International Relations (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Media &amp; Communication</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Media &amp; Communication (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Music</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Music (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Musical Theatre</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Musical Theatre (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Philosophy &amp; Ethics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Philosophy &amp; Ethics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Politics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Politics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting and Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Art History and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Art History and Business Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Art History and Contemporary Craft</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Art History and Contemporary Fashion Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Art History and Creative Industries Business Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Art History and Creative Writing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Art History and Early Childhood</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Art History and Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Art History and Film &amp; Visual Culture</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Art History and Media &amp; Communication</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Art History and Philosophy &amp; Ethics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Art History and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Art History and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Artificial Intelligence</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Artificial Intelligence (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Artificial Intelligence (with Year in Industry)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Arts &amp; Wellbeing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Childhood &amp; Youth</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Childhood &amp; Youth (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Computer Science</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Computer Science (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Dance</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Dance (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Digital Marketing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Digital Marketing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Economics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Economics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Film &amp; Visual Culture</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Film &amp; Visual Culture (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Food &amp; Nutritional Sciences</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Food &amp; Nutritional Sciences (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Geography</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Geography (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and History</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and History (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Human Geography</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Human Geography (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Information Technology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Information Technology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and International Relations</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and International Relations (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Law</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Law (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Mathematics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Mathematics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Music Production</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Music Production (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Musical Theatre</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Musical Theatre (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Sport &amp; Exercise Science</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Sport &amp; Exercise Science (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Sport &amp; Physical Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Sport &amp; Physical Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Tourism</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business Management and Tourism (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Contemporary Craft</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Contemporary Craft (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Creative Writing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Creative Writing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Drama</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Drama (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Early Childhood</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Early Childhood (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Politics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Politics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Social Care</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Social Care (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Sport &amp; Physical Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Sport &amp; Physical Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Childhood &amp; Youth and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science (with Foundation Year and Year in Industry)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science (with Year in Industry)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Creative Industries Business Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Creative Industries Business Management (with foundation year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Criminology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Criminology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Digital Marketing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Digital Marketing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Geography</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Geography (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and History</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and History (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Music Production</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Music Production (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Philosophy &amp; Ethics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Philosophy &amp; Ethics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Global Philosophies &amp; Worldviews</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science and Global Philosophies &amp; Worldviews (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Conservation Biology and Digital Marketing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Conservation Biology and Digital Marketing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Conservation Biology and Geography</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Conservation Biology and Geography (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Contemporary Fashion Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Contemporary Fashion Design (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Creative Writing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Creative Writing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Dance</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Dance (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Digital Marketing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Digital Marketing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Early Childhood</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Early Childhood (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and English Language</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and English Language (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and English Literature</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and English Literature (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Film &amp; Visual Culture</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Film &amp; Visual Culture (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Health &amp; Wellbeing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Health &amp; Wellbeing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Music</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Music (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Music Production</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Music Production (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Musical Theatre</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Musical Theatre (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Special Educational Needs</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Craft and Special Educational Needs (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Fashion Design and Creative Industries Business Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Fashion Design and Creative Industries Business Management (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Fashion Design and Digital Marketing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Contemporary Fashion Design and Digital Marketing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Creative Writing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Creative Writing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Dance</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Dance (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and English Language</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and English Language (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and English Literature</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and English Literature (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Film &amp; Visual Culture</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Film &amp; Visual Culture (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Music</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Music (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Music Production</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Music Production (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Musical Theatre</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Musical Theatre (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Tourism</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Industries Business Management and Tourism (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Criminology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Criminology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Dance</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Dance (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Drama</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Drama (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and English Literature</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and English Literature (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Global Philosophy &amp; Worldviews</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Global Philosophy &amp; Worldviews (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and History</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and History (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Media &amp; Communication</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Media &amp; Communication (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Philosophy &amp; Ethics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Philosophy &amp; Ethics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Drama</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Drama (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Early Childhood</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Early Childhood (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Film &amp; Visual Culture</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Film &amp; Visual Culture (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Human Biology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Human Biology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Law</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Law (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Media &amp; Communication</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Media &amp; Communication (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Musical Theatre</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Musical Theatre (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Philosophy &amp; Ethics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Philosophy &amp; Ethics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Social Care</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Social Care (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Criminology and Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Dance and Drama</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Dance and Drama (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Dance and Early Childhood</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Dance and Early Childhood (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Dance and Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Dance and Musical Theatre</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Dance and Musical Theatre (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Dance and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Dance and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Dance and Sport &amp; Physical Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Dance and Sport &amp; Physical Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Creativity and Digital Marketing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Creativity and Digital Marketing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Drama</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Drama (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Early Childhood</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Early Childhood (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Economics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Economics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and English Language</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and English Language (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Film &amp; Visual Culture</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Film &amp; Visual Culture (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Food &amp; Nutritional Sciences</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Food &amp; Nutritional Sciences (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Information Technology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Information Technology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Law</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Law (with Foundation year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Mathematics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Mathematics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Media &amp; Communication</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Media &amp; Communication (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Musical Theatre</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Musical Theatre (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Philosophy &amp; Ethics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Philosophy &amp; Ethics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Politics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Politics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Sport &amp; Physical Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Marketing and Sport &amp; Physical Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama &amp; Theatre</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama &amp; Theatre (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and English Language</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and English Language (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and English Literature</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and English Literature (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and Film &amp; Visual Culture</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and Film &amp; Visual Culture (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and History</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and History (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and Music</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and Music (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and Music Production</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and Music Production (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and Musical Theatre</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and Musical Theatre (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drama and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood and Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood and Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood and Global Philosophy &amp; Worldviews</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood and Global Philosophy &amp; Worldviews (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood and Health &amp; Wellbeing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood and Health &amp; Wellbeing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood and Social Care</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood and Social Care (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood and Special Educational Needs</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Childhood and Special Educational Needs (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Early Education Primary (3-7) with QTS</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Economics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Economics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Economics and History</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Economics and History (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Economics and Philosophy &amp; Ethics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Economics and Philosophy &amp; Ethics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Economics and Politics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Economics and Politics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Economics and Sport &amp; Exercise Science</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Economics and Sport &amp; Exercise Science (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and English Language</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and English Language (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and English Literature</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and English Literature (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Food &amp; Nutritional Sciences</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Food &amp; Nutritional Sciences (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Global Philosophy &amp; Worldviews</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Global Philosophy &amp; Worldviews (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Mathematics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Mathematics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Music</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Music (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Musical Theatre</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Musical Theatre (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Special Educational Needs</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Special Educational Needs (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Sport &amp; Physical Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Education and Sport &amp; Physical Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Electronic &amp; Computer Engineering</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Electronic &amp; Computer Engineering (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Electronic &amp; Computer Engineering (with Year in Industry)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Language</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Language (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Language and English Literature</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Language and English Literature (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Language and Global Philosophy &amp; Worldviews</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Language and Global Philosophy &amp; Worldviews (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Language and Media &amp; Communication</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Language and Media &amp; Communication (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Language and Special Educational Needs</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Language and Special Educational Needs (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Film &amp; Visual Culture</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Film &amp; Visual Culture (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Law</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Law (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Media &amp; Communication</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Media &amp; Communication (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Music</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Music (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Philosophy &amp; Ethics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Philosophy &amp; Ethics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Politics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Politics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English Literature and Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Environmental Science</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Environmental Science (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Film &amp; Visual Culture and Global Philosophy &amp; Worldviews</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Film &amp; Visual Culture and Global Philosophy &amp; Worldviews (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Film &amp; Visual Culture and Media &amp; Communication</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Film &amp; Visual Culture and Media &amp; Communication (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Film &amp; Visual Culture and Music Production</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Film &amp; Visual Culture and Music Production (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Film &amp; Visual Culture and Philosophy &amp; Ethics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Film &amp; Visual Culture and Philosophy &amp; Ethics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Film, TV, Radio &amp; Media Production</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Film, TV, Radio &amp; Media Production (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Fine Art</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Fine Art (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Food &amp; Nutritional Sciences</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Food &amp; Nutritional Sciences and Health &amp; Wellbeing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Food &amp; Nutritional Sciences and Health &amp; Wellbeing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Food &amp; Nutritional Sciences and Human Biology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Food &amp; Nutritional Sciences and Human Biology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Food &amp; Nutritional Sciences and Media &amp; Communication</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Food &amp; Nutritional Sciences and Media &amp; Communication (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Food &amp; Nutritional Sciences and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Food &amp; Nutritional Sciences and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Food &amp; Nutritional Sciences and Sport &amp; Exercise Science</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Food &amp; Nutritional Sciences and Sport &amp; Exercise Science (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Game Art &amp; Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Game Art &amp; Design (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Geography</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Geography (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Geography and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Geography and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Geography and Sport &amp; Physical Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Geography and Sport &amp; Physical Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophy &amp; Worldviews and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophy &amp; Worldviews and International Relations</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophy &amp; Worldviews and International Relations (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophy &amp; Worldviews and Media &amp; Communication</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophy &amp; Worldviews and Media &amp; Communication (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophy &amp; Worldviews and Politics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophy &amp; Worldviews and Politics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophy &amp; Worldviews and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophy &amp; Worldviews and Social Care</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophy &amp; Worldviews and Social Care (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Graphic Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Graphic Design (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Health &amp; Social Care</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Health &amp; Social Care (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Health &amp; Wellbeing and Human Biology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Health &amp; Wellbeing and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Health &amp; Wellbeing and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Health &amp; Wellbeing and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Health &amp; wellbeing and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Health &amp; Wellbeing and Social Care</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Health &amp; Wellbeing and Social Care (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Health &amp; Wellbeing and Sport &amp; Physical Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Health &amp; Wellbeing and Sport &amp; Physical Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Law</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Law (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Media &amp; Communication</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Media &amp; Communication (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Philosophy &amp; Ethics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Philosophy &amp; Ethics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Politics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Politics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">History and Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Human Biology and Sport &amp; Exercise Science</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Human Biology and Sport &amp; Exercise Science (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Information Technology and Media &amp; Communication</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Information Technology and Media &amp; Communication (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Information Technology and Music Production</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Information Technology and Music Production (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">International Relations and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">International Relations and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">International Relations and Tourism</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">International Relations and Tourism (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">LLB Law</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Law (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Law and Philosophy &amp; Ethics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Law and Philosophy &amp; Ethics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Law and Politics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Law and Politics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Law and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Law and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Mathematics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Mathematics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Mathematics (with Year in Industry)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Media &amp; Communication and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Media &amp; Communication and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Media &amp; Communication and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Media &amp; Communication and Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Media &amp; Communication and Special Educational Needs</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Media &amp; Communication and Special Educational Needs (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Media &amp; Communication and Tourism</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Media &amp; Communication and Tourism (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music and Music Production</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music and Music Production (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music and Politics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music and Politics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music Production</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music Production (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music Production and Musical Theatre</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music Production and Musical Theatre (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music Production and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Musical Theatre and Politics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Musical Theatre and Politics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Musical Theatre and Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Musical Theatre and Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophies &amp; Worldviews and Philosophy &amp; Ethics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophies &amp; Worldviews and Philosophy &amp; Ethics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Philosophy &amp; Ethics and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Philosophy &amp; Ethics and Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Philosophy &amp; Ethics and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Philosophy &amp; Ethics and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Politics &amp; International Relations</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Politics &amp; International Relations (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Politics and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Politics and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Politics and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Politics and Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Primary Education with QTS (5-11)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology and Religion, Theology &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology and Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology and Special Educational Needs</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology and Special Educational Needs (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology and Sport &amp; Exercise Science</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology and Sport &amp; Exercise Science (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology in Business</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology in Business (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology in Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Psychology in Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Religion, Theology &amp; Spirituality and Social Care</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Religion, Worldviews &amp; Spirituality</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Religion, Worldviews &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophies &amp; Worldviews and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophies &amp; Worldviews and Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophies &amp; Worldviews and Sport &amp; Physical Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Global Philosophies &amp; Worldviews and Sport &amp; Physical Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Robotics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Robotics (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Robotics (with Year in Industry and Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Robotics (with Year in Industry)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Social Care and Religion, Theology &amp; Spirituality (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Social Care and Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Social Care and Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Social Care and Special Educational Needs</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Social Care and Special Educational Needs (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Social Care and Sport &amp; Physical Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Social Care and Sport &amp; Physical Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Social Work</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Social Work (MA) (PG)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sociology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Software Engineering BEng</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Software Engineering BSc</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Software Engineering (with Foundation Year and Year in Industry) BSc</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Software Engineering (with Foundation Year and Year in Industry) BEng</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Software Engineering (with Foundation Year) BSc</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Software Engineering (with Foundation Year) BEng</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Software Engineering (with Year in Industry) BSc</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Software Engineering (with Year in Industry) BEng</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Special Educational Needs &amp; Disability Studies</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Special Educational Needs &amp; Disability Studies (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Special Educational Needs and Sport &amp; Physical Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Religion, Theology &amp; Spirituality and Special Educational Needs</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Religion, Theology &amp; Spirituality and Special Educational Needs (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Special Educational Needs and Sport &amp; Physical Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sport &amp; Exercise Nutrition</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sport &amp; Exercise Nutrition (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sport &amp; Exercise Science</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sport &amp; Exercise Science (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sport &amp; Physical Education</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sport &amp; Physical Education (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sport Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sport Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sport Psychology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sport Rehabilitation</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Tourism Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Tourism Management (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Religion, Theology &amp; Spirituality and Special Educational Needs</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Religion, Theology &amp; Spirituality and Special Educational Needs (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Human Biology and Criminology (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Human Biology and Health &amp; Wellbeing (with Foundation year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Human Biology and Food &amp; Nutritional Sciences (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Conservation Biology and Geography</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Conservation Biology and Geography (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Creativity and Digital Marketing (with Foundation Year)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Digital Creativity and Music Production (with Foundation Year)</li>\r\n</ul>\r\n<a href=\"https://www.hope.ac.uk/undergraduate/\" target=\"_blank\" rel=\"noopener\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nNormally a first or second class degree from a recognised American University\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n<ul>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Advanced Computer Science</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">PG Cert Advanced Mentoring &amp; Coaching \u2013 Online</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Advanced Mentoring and Coaching</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Advanced Musculoskeletal (MSK) Practice</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Applied Developmental Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Business Sustainability</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">PG Cert Catholic Pastoral Leadership</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Cognition and Aesthetics</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Contemporary Performance</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Creative Approaches to Children\u2019s Wellbeing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Creative Music Practice</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Dance Professional Practice</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Data Science</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Digital Marketing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Disability and Interdisciplinary Professional Practice</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Disability Studies</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Early Childhood</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Ecology &amp; Environmental Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Education (MA)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">EdD Education Doctorate (EdD)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">PG Cert Education Leadership &amp; Management \u2013 Online</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Education Leadership and Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA English Literature</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA English Literature (MA by Research)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MRes Green Criminology and Environmental Crime</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Health &amp; Social Care</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">DHSC Health &amp; Social Care Doctorate (DHSC)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA History</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc International Business Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA International Criminology and Security Studies</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">LLM International Cyber Law and Policy (LLM by Research)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MRes International Terrorism and Extremism Studies</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MBA Masters in Business Administration</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">LLM Migration and Refugee Law (LLM by Research)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Musculoskeletal (MSK) Practice</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">PG Cert Musculoskeletal Practice (First Contact Practice)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">PGCE PGCE Primary (3-7)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">PGCE PGCE Primary (5-11)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">PGCE PGCE Secondary</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Physiotherapy</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Politics &amp; International Relations</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Psychology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Robotics Engineering</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Social Policy</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Social Work</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">DSW Social Work Doctorate (DSW)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Socio-Cultural Disability Studies</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Sociology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Special Educational Needs and Inclusion Studies</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">PG Cert Specific Learning Difficulties (Dyslexia) \u2013 Online (PG Cert)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Sports Medicine, Exercise and Health</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Theology, Philosophy &amp; Religion (MA by Research)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Theology, Philosophy &amp; Religion</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MRes Transactional Crime</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">PG Cert Understanding Autism &amp; Inclusive Learning \u2013 Online (PGCert)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Youth Work &amp; Community Development</li>\r\n</ul>\r\n<a href=\"https://www.hope.ac.uk/postgraduate/\" target=\"_blank\" rel=\"noopener\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/LiverpoolHopeUniversity\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://x.com/LiverpoolHopeUK\" target=\"_blank\" rel=\"noopener\">\r\nTwitter\r\n</a>\r\n<a href=\"https://www.instagram.com/liverpoolhopeuk/\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/liverpoolhopeuni1\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.hope.ac.uk/\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.hope.ac.uk/international/yourcountry/usa/\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.hope.ac.uk/international/feesandscholarships/internationaltuitionfees/\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.hope.ac.uk/international/feesandscholarships/\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.hope.ac.uk/international/feesandscholarships/fundingforusstudents/\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.hope.ac.uk/events/\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.hope.ac.uk/research/\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.hope.ac.uk/halls/\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.hope.ac.uk/careers/\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.hopesu.com/groups#club-society%23all\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"https://www.hope.ac.uk/\" target=\"_blank\" rel=\"noopener\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"Liverpool Hope University","post_link":"https://theukstudyexpert.com/universities/liverpool-hope-university/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Liverpool Hope University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/LHU-logo-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"Business Economics, Creativeperforming Arts Design, Education, Engineering, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"4","taxonomy=category":"Universities","taxonomy=post_tag":"Business Economics, Creativeperforming Arts Design, Education, Engineering, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"Liverpool, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":18060,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"University of Hertfordshire","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Hertfordshire\" width=\"300\" height=\"169\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/hertford-white-logo-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/university-of-hertfordshire/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Hertfordshire</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                The University of Hertfordshire has been an innovative, vocation-first educational force for more than 70 years. Herts is the only university to be awarded a King\u2019s Award for Enterprise this year, recognition for how it has grown its international community, and an extensive overseas partner network delivering the University's education.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"The University of Hertfordshire has been an innovative, vocation-first educational force for more than 70 years. Herts is the only university to be awarded a King\u2019s Award for Enterprise this year, recognition for how it has grown its international community, and an extensive overseas partner network delivering the University's education.","address":"College Ln, Hatfield AL10 9AB, UK","location":{"lat":"51.75177189999999","state":"England","country":"United Kingdom","lng":"-0.2399995","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/university-of-hertfordshire/","zoom":5,"extra_fields":{"post_excerpt":"The University of Hertfordshire has been an innovative, vocation-first educational force for more than 70 years. Herts is the only university to be awarded a King\u2019s Award for Enterprise this year, recognition for how it has grown its international community, and an extensive overseas partner network delivering the University's education.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/University-of-Hertfordshire-Science-Building.png\" alt=\"University of Hertfordshire\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/University-of-Hertfordshire-Law-Building.png\" alt=\"University of Hertfordshire\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/University-of-Hertfordshire-College-Lane-Campus.png\" alt=\"University of Hertfordshire\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/University-of-Hertfordshire-Aerial-Shot-.png\" alt=\"University of Hertfordshire\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/University-of-Hertfordshire-Learning-Resource-Center.png\" alt=\"University of Hertfordshire\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/University-of-Hertfordshire-Campus-Beacon-.png\" alt=\"University of Hertfordshire\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact University of Hertfordshire\r\n</a>\r\n\r\n<strong>Location:</strong> Hatfield, Hertfordshire, AL10 9AB, UK\r\n\r\n<strong>Website: </strong><a href=\"https://www.herts.ac.uk/\">https://www.herts.ac.uk/</a>\r\n<h3>Overview</h3>\r\nThe University of Hertfordshire: Powering potential. Accelerating growth.\r\nWhether it\u2019s in learning, teaching, or business partnership, the University of Hertfordshire transforms bold ambition into life-changing reality.\r\n\r\nDefined by the spirit of innovation and enterprise, the University of Hertfordshire has been an innovative, vocation-first educational force for more than 70 years.\r\n\r\nFrom our start as a leading educator within Britain\u2019s aeronautical industry to our extensive offering today, we have always specialised in providing the environment and expertise needed to power every kind of potential.\r\n\r\nFor our thriving community of nearly 35,000 students from over 110 countries, that means high-quality teaching from experts engaged in groundbreaking research with real-world impact. Students have access to more than 700 career-focused degree options and a chance to study at more than 170 universities worldwide, using outstanding, true to life facilities. Herts is the only university to be awarded a King\u2019s Award for Enterprise this year, recognition for how it has grown its international community, and an extensive overseas partner network delivering the University's education.\r\n\r\n<strong>Population: </strong>36,000\r\n\r\n<strong>Campus Type:\u00a0</strong>Suburban\r\n<h3>Quick Facts</h3>\r\n<ul>\r\n \t<li>1st in the East of England for overall student satisfaction</li>\r\n \t<li>Only university to be awarded a King\u2019s Award for Enterprise</li>\r\n \t<li>25 minutes from London Kings X. The university is based on a 125 acre green campus in Hatfield</li>\r\n \t<li>96.5% of our graduates are in work (or further study) within 6 months</li>\r\n \t<li>78% of research ranked as world-leading or internationally excellent, Research Excellence Framework (REF)</li>\r\n \t<li>The vast majority of our courses have a placement/internship option</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://youtu.be/-WbADLjWZxU?si=q_WJMAkh2T92PTDBhttps://youtu.be/jUTTGluJTbs?si=nrUMJIaoAtYzyliohttps://youtu.be/VIgrd4DXGE4?si=ncXYC-PdSs4MbICVhttps://youtu.be/k2ku4qeZjwc?si=o3R1cDcO-MmyOnRihttps://youtu.be/Ol80Y10Me_8?si=orlurYrrxaoOMEN0https://youtu.be/PwBtjFEv8UU?si=6wcCv3OFxI4tvITY\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nHigh School Diploma with a minimum overall average of 3.0, with one of the following;\r\n\r\n2 Advanced Placement (AP) with a minimum score of 3.0\r\n\r\nOR\r\n\r\nSAT One with a balanced score of 1600 (old SAT) or 1070 (new SAT)\r\n\r\nOR\r\n\r\nACT with a composite score of 23\r\nA degree with a specific A Level subject requirement would need an honours class/college credit class in that specific subject.\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n<ul>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Accounting 112\u2013120 N400</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Accounting and Finance 120\u2013128 NN43</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Business and Accounting 112\u2013120 NN4D</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Business and Finance 120\u2013128 NN13</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Economics and Finance 120\u2013128 L1N3</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Finance 120\u2013128 N300</li>\r\n \t<li aria-level=\"1\">BA (Hons) 2D Digital Animation 112\u2013120 W618</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) 3D Animation and Visual Effects 112\u2013120 W282</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) 3D Games Art &amp; Design 112\u2013120 W281</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Comics and Concept Art 112\u2013120 W619</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Creative Media Arts 112\u2013120 W287</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Creative Media Technology 112\u2013120 W288</li>\r\n \t<li aria-level=\"1\">BA (Hons) Film and Television Production 112\u2013120 W602</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Games Design and Development (top up) W203</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Architecture 120\u2013128 K100</li>\r\n \t<li aria-level=\"1\">BA (Hons) Interior Architecture and Design 112\u2013120 W251</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Advertising and Digital Marketing 112\u2013120 N595</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Business Administration 112\u2013120 N252</li>\r\n \t<li aria-level=\"1\">BA (Hons) Business Administration (Online) 112\u2013120</li>\r\n \t<li aria-level=\"1\">BA (Hons) Business Administration (top-up) (Online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Business Economics 112\u2013120 L112</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Business Management 112\u2013120 N100</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Business Management with Information Systems 112\u2013120 N150</li>\r\n \t<li aria-level=\"1\">BA (Hons) Business Management with Leadership 112\u2013120 N151</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Business and Human Resource Management 112\u2013120 N607</li>\r\n \t<li aria-level=\"1\">BA (Hons) Business and Marketing 112\u2013120 NN1M</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Business and Sport Management (Online) 104\u2013112</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Economics 120\u2013128 L101</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Economics and Finance 120\u2013128 L1N3</li>\r\n \t<li aria-level=\"1\">BA (Hons) Event Management 104\u2013112 N820</li>\r\n \t<li aria-level=\"1\">BA (Hons) Event Management and Tourism 104\u2013112 N891</li>\r\n \t<li aria-level=\"1\">BA (Hons) Fashion and Fashion Business 112\u2013120 W231</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Finance 120\u2013128 N300</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons)(SW/YAB) International Business 120\u2013128 N120</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) International Business Management (Top Up) N128</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) International Business with French 120\u2013128 N121</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) International Business with German 120\u2013128 N122</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) International Business with Japanese 120\u2013128 N123</li>\r\n \t<li aria-level=\"1\">BA (Hons) International Business with Mandarin 120\u2013128 N124</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) International Business with Spanish 120\u2013128 N125</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) International Tourism Management with Placement Year 112\u2013120 N830</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Leadership and Professional Development</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BA (Hons) Marketing 112\u2013120 N500</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Sports Business Management 104\u2013112 N880</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Computer Science 120\u2013128 G400</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Computer Science (Applied Data Science) (Online) 120\u2013128</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Computer Science (Applied Data Science) (Top Up) (Online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Computer Science (Artificial Intelligence) 120\u2013128 GG47</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Computer Science (Cyber Security and Networks) 120\u2013128 G491</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Computer Science (Online) 120\u2013128</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Computer Science (Software Engineering) 120\u2013128 GG46</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Computer Science (Top Up) (Online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">BSc (Hons) Computer Science (top-up) G403</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Data Science 120\u2013128 G200</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Information Technology 120 \u2013 128 G501</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Information Technology (Online) 120\u2013128</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Information Technology (Top Up) (Online)</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Information Technology (top-up)</li>\r\n \t<li aria-level=\"1\">MEng (Hons) Robotics and Artificial Intelligence 128\u2013136 H672</li>\r\n \t<li aria-level=\"1\">BEng (Hons) Robotics and Artificial Intelligence 120\u2013128 H671</li>\r\n \t<li aria-level=\"1\">Bachelor of Education Honours Degree Primary with QTS 112\u2013120 X122</li>\r\n \t<li aria-level=\"1\">BA (Hons) Early Childhood Education 104\u2013112 X310</li>\r\n \t<li aria-level=\"1\">BA (Hons) Education 104\u2013112 X305</li>\r\n \t<li aria-level=\"1\">BA (Hons) Psychology in Education 112\u2013120 X311</li>\r\n \t<li aria-level=\"1\">MEng (Hons) Aerospace Engineering 128-136 H401</li>\r\n \t<li aria-level=\"1\">BEng (Hons) Aerospace Engineering 120\u2013128 H410</li>\r\n \t<li aria-level=\"1\">MEng (Hons) Aerospace Engineering with Pilot Studies 128?136 H497</li>\r\n \t<li aria-level=\"1\">BEng (Hons) Aerospace Engineering with Pilot Studies 120?128 H496</li>\r\n \t<li aria-level=\"1\">MEng (Hons) Aerospace Engineering with Space Technology 128\u2013136 H402</li>\r\n \t<li aria-level=\"1\">BEng (Hons) Aerospace Engineering with Space Technology 120?128 H400</li>\r\n \t<li aria-level=\"1\">BEng (Hons) Automotive Engineering 120 \u2013 128 H330</li>\r\n \t<li aria-level=\"1\">MEng (Hons) Automotive Engineering 128 \u2013 136 H341</li>\r\n \t<li aria-level=\"1\">BEng (Hons) Automotive Engineering with Motorsport 120\u2013128 H335</li>\r\n \t<li aria-level=\"1\">MEng (Hons) Automotive Engineering with Motorsport 128\u2013136 H336</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Automotive Technology 104\u2013112 H342</li>\r\n \t<li aria-level=\"1\">MEng (Hons) Civil Engineering 120\u2013128 H200</li>\r\n \t<li aria-level=\"1\">BEng (Hons) Civil Engineering 112-120 H201</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Computer Science (Artificial Intelligence) 120\u2013128 GG47</li>\r\n \t<li aria-level=\"1\">BEng (Hons) Electrical and Electronic Engineering 120-128 H600</li>\r\n \t<li aria-level=\"1\">Engineering with Foundation Year (Oaklands College) 48 H100</li>\r\n \t<li aria-level=\"1\">MEng (Hons) Mechanical Engineering 128\u2013136 H301</li>\r\n \t<li aria-level=\"1\">BEng (Hons) Mechanical Engineering 120\u2013128 H300</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Motorsport Technology 104\u2013112 H331</li>\r\n \t<li aria-level=\"1\">BEng (Hons) Robotics and Artificial Intelligence 120\u2013128 H671</li>\r\n \t<li aria-level=\"1\">MEng (Hons) Robotics and Artificial Intelligence 128\u2013136 H672</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Language and Applied Linguistics 112\u2013120 Q151</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Language and Creative Writing 112\u2013120 Q1W1</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Language and Journalism 112\u2013120 Q1P9</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Language and Linguistics 112\u2013120 Q150</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Language and Literature 112\u2013120 Q1Q3</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Language and Media 112\u2013120 Q1P7</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Language with English Language Teaching 112\u2013120 Q1X3</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Language with Film 112\u2013120 Q1W6</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Literature 112\u2013120 Q350</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Literature and Creative Writing 112\u2013120 Q3W1</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Literature and Journalism 112\u2013120 Q3P9</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Literature and Media 112\u2013120 Q3P7</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Literature with Film 112\u2013120 Q3W6</li>\r\n \t<li aria-level=\"1\">BA (Hons) History and Creative Writing 112\u2013120 V1W1</li>\r\n \t<li aria-level=\"1\">BA (Hons) History and English Language 112\u2013120 V1Q1</li>\r\n \t<li aria-level=\"1\">BA (Hons) History and English Literature 112\u2013120 V1Q3</li>\r\n \t<li aria-level=\"1\">BA (Hons) History and Journalism 112\u2013120 V1P9</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy and Creative Writing 112\u2013120 V5W1</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy and English Language 112\u2013120 V5Q1</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy and English Literature 112\u2013120 V5Q3</li>\r\n \t<li aria-level=\"1\">BA (Hons) Architecture 120\u2013128 K100</li>\r\n \t<li aria-level=\"1\">BA (Hons) Character and Creative Effects 112\u2013120 W614</li>\r\n \t<li aria-level=\"1\">BA (Hons) Comics and Concept Art 112\u2013120 W619</li>\r\n \t<li aria-level=\"1\">BA (Hons) Creative Media Arts 112\u2013120 W287</li>\r\n \t<li aria-level=\"1\">BA (Hons) Fashion and Fashion Business 112\u2013120 W231</li>\r\n \t<li aria-level=\"1\">BA (Hons) Graphic Design 112\u2013120 W210</li>\r\n \t<li aria-level=\"1\">BA (Hons) Graphic Design Advertising and Branding 112\u2013120 W215</li>\r\n \t<li aria-level=\"1\">BA (Hons) Illustration 112\u2013120 W221</li>\r\n \t<li aria-level=\"1\">BA (Hons) Interior Architecture and Design 112\u2013120 W251</li>\r\n \t<li aria-level=\"1\">BA (Hons) Model Design and Special Effects 112\u2013120 W615</li>\r\n \t<li aria-level=\"1\">BA (Hons) Visual Merchandising, Styling and Promotion (top up) W202</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Biochemistry 112\u2013120 C1CR</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Biological Science 104\u2013112 C902</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Biomedical Science 112\u2013120 B990</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Biomedical and Healthcare Science (North Hertfordshire College) 48 B904</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Biomedical and Healthcare Science (Hertford Regional College) 48 B904</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Biomedical and Healthcare Science (West Herts College) 48 B904</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Biomedical and Healthcare Science (Oaklands College) 48 B904</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Pharmaceutical Science 112\u2013120 B202</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Pharmacology 120\u2013128 B210</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Environmental Management and Ecology 112-120 F750</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Geography 112-120 F800</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Geography &amp; Environmental Sciences (Oaklands College) 48 B906</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Geography &amp; Environmental Sciences (North Hertfordshire College) 48 B906</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Geography &amp; Environmental Sciences (Hertford Regional College) 48 B906</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Geography &amp; Environmental Sciences (West Herts College) 48 B906</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Diagnostic Radiography and Imaging 120\u2013128 B821</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Dietetics 128\u2013136 B410</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Biomedical and Healthcare Science (North Hertfordshire College) 48 B904</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Biomedical and Healthcare Science (Hertford Regional College) 48 B904</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Biomedical and Healthcare Science (West Herts College) 48 B904</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Biomedical and Healthcare Science (Oaklands College) 48 B904</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Optometry 96 B511</li>\r\n \t<li aria-level=\"1\">MOptom Master of Optometry 136\u2013144 B510</li>\r\n \t<li aria-level=\"1\">Master of Pharmacy 128 \u2013 136 B230</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Midwifery (Pre-registration) 120\u2013128 B720</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Midwifery (Pre-registration, Shortened)</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Nursing (Adult) 112\u2013120 B700</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Nursing (Child) 112\u2013120 B702</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Nursing (Learning Disabilities) 112\u2013120 B761</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Nursing (Mental Health) 112\u2013120 B701</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Paramedic Science 112 \u2013 120 B780</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Physiotherapy 128-136 B160</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Social Work 112 \u2013 120 L500</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Therapeutic Radiography 112 \u2013 120 B823</li>\r\n \t<li aria-level=\"1\">BA (Hons) History 112\u2013120 V150</li>\r\n \t<li aria-level=\"1\">BA (Hons) History and Creative Writing 112\u2013120 V1W1</li>\r\n \t<li aria-level=\"1\">BA (Hons) History and English Language 112\u2013120 V1Q1</li>\r\n \t<li aria-level=\"1\">BA (Hons) History and English Literature 112\u2013120 V1Q3</li>\r\n \t<li aria-level=\"1\">BA (Hons) History and Journalism 112\u2013120 V1P9</li>\r\n \t<li aria-level=\"1\">BA (Hons) History and Philosophy 112\u2013120 V1VP</li>\r\n \t<li aria-level=\"1\">BA (Hons) History with Film 112\u2013120 V1W6</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy 112\u2013120 V550</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy and Creative Writing 112\u2013120 V5W1</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy and English Language 112\u2013120 V5Q1</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy and English Literature 112\u2013120 V5Q3</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy and Journalism 112\u2013120 V5P9</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy and Media 112\u2013120 V5P7</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy with Film 112\u2013120 V5W6</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy, Religion and Ethics 112\u2013120 V5V8</li>\r\n \t<li aria-level=\"1\">Bachelor of Laws LLB (Hons) 120?128 M100</li>\r\n \t<li aria-level=\"1\">Bachelor of Laws LLB (Hons) (Accelerated) 128?136 M101</li>\r\n \t<li aria-level=\"1\">BA (Hons) Criminology and Criminal Justice 112\u2013120 M211</li>\r\n \t<li aria-level=\"1\">Law with Foundation Year (West Herts College) 48 M102</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Professional Policing 112\u2013120 M300</li>\r\n \t<li aria-level=\"1\">BA (Hons) Creative Writing and Digital Media P902</li>\r\n \t<li aria-level=\"1\">BA (Hons) Digital Media and Communications 112\u2013120 P700</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Language and Journalism 112\u2013120 Q1P9</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Language and Media 112\u2013120 Q1P7</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Language with Film 112\u2013120 Q1W6</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Literature and Journalism 112\u2013120 Q3P9</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Literature and Media 112\u2013120 Q3P7</li>\r\n \t<li aria-level=\"1\">BA (Hons) English Literature with Film 112\u2013120 Q3W6</li>\r\n \t<li aria-level=\"1\">BA (Hons) History and Journalism 112\u2013120 V1P9</li>\r\n \t<li aria-level=\"1\">BA (Hons) History and Philosophy 112\u2013120 V1VP</li>\r\n \t<li aria-level=\"1\">BA (Hons) History with Film 112\u2013120 V1W6</li>\r\n \t<li aria-level=\"1\">BA (Hons) Journalism and Creative Writing 112\u2013120 P900</li>\r\n \t<li aria-level=\"1\">BA (Hons) Journalism and Digital Media 112\u2013120 P903</li>\r\n \t<li aria-level=\"1\">BA (Hons) Mass Communications 112\u2013120 P300</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy and Journalism 112\u2013120 V5P9</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy and Media 112\u2013120 V5P7</li>\r\n \t<li aria-level=\"1\">BA (Hons) Philosophy with Film 112\u2013120 V5W6</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Audio Engineering 112\u2014120 W374</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Live Sound, Lighting and Performance Technology 112\u2014120 W376</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Music Composition and Sound for Film and Games 112\u2014120 W392</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Music Production and Promotion 112\u2014120 W375</li>\r\n \t<li aria-level=\"1\">BA (Hons) Performing Arts (top up) W204</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Songwriting and Artist Development 112\u2014120 W3T4</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Astrophysics 120\u2013128 F501</li>\r\n \t<li aria-level=\"1\">MPhys (Hons) Astrophysics 128\u2013136 F511</li>\r\n \t<li aria-level=\"1\">MPhys (Hons) Astrophysics with Space Science 128\u2013136 F512</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Astrophysics with Space Science 120\u2013128 F502</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Data Science 120\u2013128 G200</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Financial Mathematics 120\u2013128 GN13</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Mathematics (North Hertfordshire College) 48 G101</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Physical Sciences (North Hertfordshire College) 48 F900</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Mathematics 120\u2013128 G100</li>\r\n \t<li aria-level=\"1\">MPhys (Hons) Physics 128\u2013136 F304</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Physics 120\u2013128 F300</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Physics with Space Science 120\u2013128 F302</li>\r\n \t<li aria-level=\"1\">MPhys (Hons) Physics with Space Science 128\u2013136 F305</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Business Economics 112\u2013120 L112</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Economics 120\u2013128 L101</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Economics and Finance 120\u2013128 L1N3</li>\r\n \t<li aria-level=\"1\">BA (Hons) Politics and International Relations 112?120 L290</li>\r\n \t<li aria-level=\"1\">BA (Hons) Sociology 112\u2013120 L300</li>\r\n \t<li aria-level=\"1\">BA (Hons) Sociology and Psychology 112\u2013120 L3C8</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Psychology (West Herts College) 48 B905</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Psychology 120\u2013128 C800</li>\r\n \t<li aria-level=\"1\">BA (Hons) Psychology in Education 112\u2013120 X311</li>\r\n \t<li aria-level=\"1\">BA (Hons) Sociology and Psychology 112\u2013120 L3C8</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Sports Studies with Psychology 104\u2013112 C603</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Business and Sport Management (Online) 104\u2013112</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Sports (Oaklands College) 48 B903</li>\r\n \t<li aria-level=\"1\">Initial Year for Extended Degree in Science \u2013 Sports (Hertford Regional College) 48 B903</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Sport and Exercise Science 112 \u2013 120 C600</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Sports Business Management 104\u2013112 N880</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Sports Coaching 104\u2013112 C610</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Sports Studies 104\u2013112 C602</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Sports Studies with Psychology 104\u2013112 C603</li>\r\n \t<li aria-level=\"1\">BSc (Hons) Sports Therapy 112\u2013 120 CB63</li>\r\n</ul>\r\n<a href=\"https://www.herts.ac.uk/courses/undergraduate-courses\" target=\"_blank\" rel=\"noopener\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nCompletion of a 4 year bachelors degree with GPA 2.5 out of 4\r\n\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n<ul>\r\n \t<li>MSc Finance and Investment Banking</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Finance and Investment Banking with Advanced Research</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Finance and Investment Banking with Extended Professional Practice</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Animation</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Character and Creature Animation (Online)</li>\r\n \t<li aria-level=\"1\">MA Concept Art</li>\r\n \t<li aria-level=\"1\">MA Digital Media Arts</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Film Production</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Games Art and Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Global Film and Television (Online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Screenwriting</li>\r\n \t<li aria-level=\"1\">MArch Architecture and Urbanism</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Interior Architecture and Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Art Therapy</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Graphic Design and Branding</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MA Illustration</li>\r\n \t<li aria-level=\"1\">MA Interior Architecture and Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Cancer Immunotherapy</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Cancer Immunotherapy with Placement Year</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Cancer Immunotherapy with Advanced Research</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Drug Discovery and Toxicology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Drug Discovery and Toxicology with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Drug Discovery and Toxicology with Advanced Research</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Medical Microbiology</li>\r\n \t<li aria-level=\"1\">MSc Medical Microbiology with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Medical Microbiology with Advanced Research</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">MSc Molecular Biotechnology</li>\r\n \t<li aria-level=\"1\">MSc Molecular Biotechnology with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Molecular Biotechnology with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc Pharmacovigilance</li>\r\n \t<li aria-level=\"1\">PgCert Pharmacovigilance</li>\r\n \t<li aria-level=\"1\">PgDip Pharmacovigilance</li>\r\n \t<li aria-level=\"1\">PgDip Pharmacy \u2013 Overseas Pharmacists Assessment Programme (OSPAP)</li>\r\n \t<li aria-level=\"1\">PgDip Pharmacy Practice</li>\r\n \t<li aria-level=\"1\">MSc Business Analytics and Consultancy</li>\r\n \t<li aria-level=\"1\">MSc Business Psychology</li>\r\n \t<li aria-level=\"1\">MSc Finance and Investment Banking</li>\r\n \t<li aria-level=\"1\">MSc Finance and Investment Banking with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc Finance and Investment Banking with Extended Professional Practice</li>\r\n \t<li aria-level=\"1\">Global Executive Master of Business Administration (Online)</li>\r\n \t<li aria-level=\"1\">Global Executive Master of Business Administration with Algorithmic Marketing (Online)</li>\r\n \t<li aria-level=\"1\">Global Executive Master of Business Administration with Artificial Intelligence (Online)</li>\r\n \t<li aria-level=\"1\">Global Executive Master of Business Administration with Cyber Security (Online)</li>\r\n \t<li aria-level=\"1\">Global Executive Master of Business Administration with Data Science (Online)</li>\r\n \t<li aria-level=\"1\">Global Executive Master of Business Administration with Sustainability (Online)</li>\r\n \t<li aria-level=\"1\">PgDip Human Resource Management</li>\r\n \t<li aria-level=\"1\">MA Human Resource Management</li>\r\n \t<li aria-level=\"1\">MA Human Resource Management with Placement Year</li>\r\n \t<li aria-level=\"1\">MA Human Resource Management (Global)</li>\r\n \t<li aria-level=\"1\">MA Human Resource Management (Work Psychology)</li>\r\n \t<li aria-level=\"1\">MA Human Resource Management with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc International Business</li>\r\n \t<li aria-level=\"1\">MSc International Business with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc International Business with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc International Tourism, Hospitality &amp; Event Management with Adv Project</li>\r\n \t<li aria-level=\"1\">MSc International Tourism, Hospitality &amp; Event Management with Ext Pro Practice</li>\r\n \t<li aria-level=\"1\">MSc International Tourism, Hospitality and Event Management</li>\r\n \t<li aria-level=\"1\">MSc Management</li>\r\n \t<li aria-level=\"1\">MSc Management (Online)</li>\r\n \t<li aria-level=\"1\">MSc Management with Digital Marketing</li>\r\n \t<li aria-level=\"1\">MSc Management with Logistics and Supply Chain Management</li>\r\n \t<li aria-level=\"1\">MSc Management with Sustainability</li>\r\n \t<li aria-level=\"1\">MSc Manufacturing Management</li>\r\n \t<li aria-level=\"1\">MSc Manufacturing Management (18-month route)</li>\r\n \t<li aria-level=\"1\">MSc Manufacturing Management with Advanced Project</li>\r\n \t<li aria-level=\"1\">MSc Manufacturing Management with Extended Professional Practice</li>\r\n \t<li aria-level=\"1\">Master of Business Administration</li>\r\n \t<li aria-level=\"1\">Master of Business Administration (Advertising and Brand Management)</li>\r\n \t<li aria-level=\"1\">Master of Business Administration (Artificial Intelligence)</li>\r\n \t<li aria-level=\"1\">Master of Business Administration (Data Analytics)</li>\r\n \t<li aria-level=\"1\">Master of Business Administration (Digital Marketing)</li>\r\n \t<li aria-level=\"1\">Master of Business Administration (FinTech)</li>\r\n \t<li aria-level=\"1\">Master of Business Administration (Global Business Development)</li>\r\n \t<li aria-level=\"1\">Master of Business Administration (Healthcare)</li>\r\n \t<li aria-level=\"1\">Master of Business Administration (Human Resources)</li>\r\n \t<li aria-level=\"1\">Master of Business Administration (Logistics and Supply Chain Management)</li>\r\n \t<li aria-level=\"1\">Master of Business Administration (Project Management)</li>\r\n \t<li aria-level=\"1\">Master of Business Administration (Risk Management and Investment)</li>\r\n \t<li aria-level=\"1\">MSc Project Management</li>\r\n \t<li aria-level=\"1\">MA Public Relations and Digital Communications</li>\r\n \t<li aria-level=\"1\">MA Public Relations and Digital Communications with Placement Year</li>\r\n \t<li aria-level=\"1\">MA Public Relations and Digital Communications with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc Strategic Marketing with Brand Leadership</li>\r\n \t<li aria-level=\"1\">MSc Strategic Marketing with Brand Leadership with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Strategic Marketing with Brand Leadership (Experiential Learning)</li>\r\n \t<li aria-level=\"1\">MSc Strategic Marketing with Digital Media Management</li>\r\n \t<li aria-level=\"1\">MSc Strategic Marketing with Digital Media Management with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Strategic Marketing with Digital Media Management (Experiential Learning)</li>\r\n \t<li aria-level=\"1\">MSc Strategic Marketing with Global Business Development</li>\r\n \t<li aria-level=\"1\">MSc Strategic Marketing with Global Business Development with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Strategic Marketing with Global Business Development (Experiential Learning)</li>\r\n \t<li aria-level=\"1\">MSc Supply Chain and Logistics Management</li>\r\n \t<li aria-level=\"1\">MSc Supply Chain and Logistics Management (18-month route)</li>\r\n \t<li aria-level=\"1\">MSc Supply Chain and Logistics Management with Advanced Project</li>\r\n \t<li aria-level=\"1\">MSc Supply Chain and Logistics Management with Extended Professional Practice</li>\r\n \t<li aria-level=\"1\">MSc Advanced Computer Science</li>\r\n \t<li aria-level=\"1\">MSc Advanced Computer Science with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Advanced Computer Science (Online)</li>\r\n \t<li aria-level=\"1\">MSc Advanced Computer Science with Research</li>\r\n \t<li aria-level=\"1\">MSc Artificial Intelligence (Online)</li>\r\n \t<li aria-level=\"1\">MSc Artificial Intelligence and Robotics</li>\r\n \t<li aria-level=\"1\">MSc Artificial Intelligence and Robotics with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Artificial Intelligence and Robotics with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc Computer Networks and Systems Security</li>\r\n \t<li aria-level=\"1\">MSc Computer Networks and Systems Security with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Computer Networks and Systems Security with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc Computer Science</li>\r\n \t<li aria-level=\"1\">MSc Computer Science (Online)</li>\r\n \t<li aria-level=\"1\">MSc Computer Science with Artificial Intelligence (Online)</li>\r\n \t<li aria-level=\"1\">MSc Computer Science with Cyber Security (Online)</li>\r\n \t<li aria-level=\"1\">MSc Computer Science with Data Analytics (Online)</li>\r\n \t<li aria-level=\"1\">MSc Computer Science with Software Engineering (Online)</li>\r\n \t<li aria-level=\"1\">MSc Cyber Security</li>\r\n \t<li aria-level=\"1\">MSc Cyber Security with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Cyber Security (Online)</li>\r\n \t<li aria-level=\"1\">MSc Cyber Security with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc Data Science</li>\r\n \t<li aria-level=\"1\">MSc Data Science with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Data Science and Analytics</li>\r\n \t<li aria-level=\"1\">MSc Data Science and Analytics with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Data Science and Analytics (Online)</li>\r\n \t<li aria-level=\"1\">MSc Data Science and Analytics with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc Data Science with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc Software Engineering</li>\r\n \t<li aria-level=\"1\">MSc Software Engineering with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Software Engineering (Online)</li>\r\n \t<li aria-level=\"1\">MSc Software Engineering with Advanced Research</li>\r\n \t<li aria-level=\"1\">MA Early Childhood Education</li>\r\n \t<li aria-level=\"1\">MA Education</li>\r\n \t<li aria-level=\"1\">MA Education with Placement Year</li>\r\n \t<li aria-level=\"1\">MA Education with Advanced Research</li>\r\n \t<li aria-level=\"1\">MA Mental Health and Wellbeing in Education (2 Year Route)</li>\r\n \t<li aria-level=\"1\">MA Mental Health and Wellbeing in Education (3 Year Route)</li>\r\n \t<li aria-level=\"1\">MSc Outdoor Environmental Education</li>\r\n \t<li aria-level=\"1\">PgCert Outdoor Environmental Education</li>\r\n \t<li aria-level=\"1\">PgDip Outdoor Environmental Education</li>\r\n \t<li aria-level=\"1\">PGCE and ProfGCE in Secondary Education Modern Foreign Languages</li>\r\n \t<li aria-level=\"1\">MA Teaching English to Speakers of Other Languages</li>\r\n \t<li aria-level=\"1\">MSc Aerospace Engineering</li>\r\n \t<li aria-level=\"1\">MSc Aerospace Engineering (18-month route)</li>\r\n \t<li aria-level=\"1\">MSc Aerospace Engineering with Advanced Project</li>\r\n \t<li aria-level=\"1\">MSc Aerospace Engineering with Extended Professional Practice</li>\r\n \t<li aria-level=\"1\">MSc Artificial Intelligence and Robotics with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Artificial Intelligence and Robotics with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc Automotive Engineering</li>\r\n \t<li aria-level=\"1\">MSc Automotive Engineering (18-month route)</li>\r\n \t<li aria-level=\"1\">MSc Automotive Engineering with Advanced Project</li>\r\n \t<li aria-level=\"1\">MSc Automotive Engineering with Extended Professional Practice</li>\r\n \t<li aria-level=\"1\">MSc Civil Engineering</li>\r\n \t<li aria-level=\"1\">MSc Communications and Information Engineering</li>\r\n \t<li aria-level=\"1\">MSc Communications and Information Engineering (18-month route)</li>\r\n \t<li aria-level=\"1\">MSc Communications and Information Engineering with Advanced Project</li>\r\n \t<li aria-level=\"1\">MSc Communications and Information Engineering with Ext Prof Practice</li>\r\n \t<li aria-level=\"1\">MSc Electronics Engineering</li>\r\n \t<li aria-level=\"1\">MSc Electronics Engineering (18-month route)</li>\r\n \t<li aria-level=\"1\">MSc Electronics Engineering with Advanced Project</li>\r\n \t<li aria-level=\"1\">MSc Electronics Engineering with Extended Professional Practice</li>\r\n \t<li aria-level=\"1\">MSc Manufacturing Management</li>\r\n \t<li aria-level=\"1\">MSc Manufacturing Management (18-month route)</li>\r\n \t<li aria-level=\"1\">MSc Manufacturing Management with Advanced Project</li>\r\n \t<li aria-level=\"1\">MSc Manufacturing Management with Extended Professional Practice</li>\r\n \t<li aria-level=\"1\">MSc Mechanical Engineering</li>\r\n \t<li aria-level=\"1\">MSc Mechanical Engineering (18-month route)</li>\r\n \t<li aria-level=\"1\">MSc Mechanical Engineering with Advanced Project</li>\r\n \t<li aria-level=\"1\">MSc Mechanical Engineering with Extended Professional Practice</li>\r\n \t<li aria-level=\"1\">MSc Power Electronics and Control</li>\r\n \t<li aria-level=\"1\">MSc Power Electronics and Control (18-month route)</li>\r\n \t<li aria-level=\"1\">MSc Power Electronics and Control with Advanced Project</li>\r\n \t<li aria-level=\"1\">MSc Power Electronics and Control with Extended Professional Practice</li>\r\n \t<li aria-level=\"1\">MSc Supply Chain and Logistics Management</li>\r\n \t<li aria-level=\"1\">MSc Supply Chain and Logistics Management (18-month route)</li>\r\n \t<li aria-level=\"1\">MSc Supply Chain and Logistics Management with Advanced Project</li>\r\n \t<li aria-level=\"1\">MSc Supply Chain and Logistics Management with Extended Professional Practice</li>\r\n \t<li aria-level=\"1\">MA Film Production</li>\r\n \t<li aria-level=\"1\">MA Folklore Studies</li>\r\n \t<li aria-level=\"1\">MA Literature and Culture (Online)</li>\r\n \t<li aria-level=\"1\">MA Screenwriting</li>\r\n \t<li aria-level=\"1\">MA Teaching English to Speakers of Other Languages</li>\r\n \t<li aria-level=\"1\">MSc Environmental Management</li>\r\n \t<li aria-level=\"1\">MSc Environmental Management for Agriculture</li>\r\n \t<li aria-level=\"1\">MSc Sustainable Planning</li>\r\n \t<li aria-level=\"1\">MSc Sustainable Planning and Environmental Management</li>\r\n \t<li aria-level=\"1\">MSc Sustainable Planning and Transport</li>\r\n \t<li aria-level=\"1\">MSc Transport Planning</li>\r\n \t<li aria-level=\"1\">PgDip Transport Planning</li>\r\n \t<li aria-level=\"1\">PgCert Transport Planning</li>\r\n \t<li aria-level=\"1\">MSc Transport Planning with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Transport Planning with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc Water and Environmental Management</li>\r\n \t<li aria-level=\"1\">MSc Advanced Clinical Practice</li>\r\n \t<li aria-level=\"1\">MSc Advanced Medical Imaging</li>\r\n \t<li aria-level=\"1\">MSc Advanced Paramedic Practice</li>\r\n \t<li aria-level=\"1\">MSc Advanced Physiotherapy</li>\r\n \t<li aria-level=\"1\">MSc Advanced Radiotherapy and Oncology Practice</li>\r\n \t<li aria-level=\"1\">PgCert Applied Mental Health Practice</li>\r\n \t<li aria-level=\"1\">MSc Clinical Dermatology</li>\r\n \t<li aria-level=\"1\">MSc Clinical Radiographic Reporting</li>\r\n \t<li aria-level=\"1\">PgDip Cognitive Behavioural Therapy</li>\r\n \t<li aria-level=\"1\">MSc Cognitive Behavioural Therapy (Top-Up)</li>\r\n \t<li aria-level=\"1\">MSc Contemporary Nursing</li>\r\n \t<li aria-level=\"1\">MSc Diagnostic Radiography and Imaging (Pre-Registration)</li>\r\n \t<li aria-level=\"1\">MSc Health and Medical Education</li>\r\n \t<li aria-level=\"1\">MSc Health and Medical Simulation</li>\r\n \t<li aria-level=\"1\">MResHSC Master of Research in Health and Social Care</li>\r\n \t<li aria-level=\"1\">Master of Midwifery (Pre-registration, Shortened)</li>\r\n \t<li aria-level=\"1\">Master of Public Health</li>\r\n \t<li aria-level=\"1\">Master of Public Health (Online)</li>\r\n \t<li aria-level=\"1\">Master of Public Health with Advanced Research</li>\r\n \t<li aria-level=\"1\">Master of Public Health with Extended Placement</li>\r\n \t<li aria-level=\"1\">Master of Public Health with Leadership in Public Health Practice (Online)</li>\r\n \t<li aria-level=\"1\">MSc Medical Imaging and Radiation Sciences \u2013 Diagnostic Imaging</li>\r\n \t<li aria-level=\"1\">MSc Medical Ultrasound</li>\r\n \t<li aria-level=\"1\">MSc Nursing (Adult)</li>\r\n \t<li aria-level=\"1\">MSc Nursing (Learning Disabilities)</li>\r\n \t<li aria-level=\"1\">MSc Nursing (Mental Health)</li>\r\n \t<li aria-level=\"1\">MSc Paramedic Science (Pre-reg)</li>\r\n \t<li aria-level=\"1\">PgDip Pharmacy \u2013 Overseas Pharmacists Assessment Programme (OSPAP)</li>\r\n \t<li aria-level=\"1\">PgDip Pharmacy Practice</li>\r\n \t<li aria-level=\"1\">MSc Physician Associate Studies</li>\r\n \t<li aria-level=\"1\">MSc Physiotherapy (Pre-Registration)</li>\r\n \t<li aria-level=\"1\">Practice Cert in Supplementary Prescribing (Diagnostic Radiographer, Dietician)</li>\r\n \t<li aria-level=\"1\">MSc Skin Integrity and Wound Management</li>\r\n \t<li aria-level=\"1\">MSc Skin Lesion Management</li>\r\n \t<li aria-level=\"1\">MSc Social Work</li>\r\n \t<li aria-level=\"1\">PgDip Social Work (Step Up to Social Work)</li>\r\n \t<li aria-level=\"1\">PgDip Specialist Community Nursing (General Practice Nursing)</li>\r\n \t<li aria-level=\"1\">MSc Strength, Conditioning and Rehabilitation</li>\r\n \t<li aria-level=\"1\">MA Folklore Studies</li>\r\n \t<li aria-level=\"1\">MA International Relations</li>\r\n \t<li aria-level=\"1\">MA International Relations with Advanced Research</li>\r\n \t<li aria-level=\"1\">MA International Relations with Placement Year</li>\r\n \t<li aria-level=\"1\">PgDip Bar Practice</li>\r\n \t<li aria-level=\"1\">LLM Bar Practice</li>\r\n \t<li aria-level=\"1\">LLM Legal Practice</li>\r\n \t<li aria-level=\"1\">PgDip Legal Practice</li>\r\n \t<li aria-level=\"1\">Master of Laws LLM</li>\r\n \t<li aria-level=\"1\">Master of Laws Business Law</li>\r\n \t<li aria-level=\"1\">Master of Laws Business Law with Placement Year</li>\r\n \t<li aria-level=\"1\">Master of Laws Business Law with Work Experience</li>\r\n \t<li aria-level=\"1\">Master of Laws Criminal Justice</li>\r\n \t<li aria-level=\"1\">Master of Laws Criminal Justice with Placement Year</li>\r\n \t<li aria-level=\"1\">Master of Laws Criminal Justice with Work Experience</li>\r\n \t<li aria-level=\"1\">Master of Laws Intellectual Property and Information Law</li>\r\n \t<li aria-level=\"1\">Master of Laws Intellectual Property and Information Law with Placement Year</li>\r\n \t<li aria-level=\"1\">Master of Laws Intellectual Property and Information Law with Work Experience</li>\r\n \t<li aria-level=\"1\">Master of Laws International Commercial Law and Arbitration</li>\r\n \t<li aria-level=\"1\">Master of Laws International Commercial Law and Arbitration with Placement Year</li>\r\n \t<li aria-level=\"1\">Master of Laws International Commercial Law and Arbitration with Work Experience</li>\r\n \t<li aria-level=\"1\">Master of Laws International Human Rights Law</li>\r\n \t<li aria-level=\"1\">Master of Laws International Human Rights Law with Placement Year</li>\r\n \t<li aria-level=\"1\">Master of Laws Solicitors\u2019 Practice</li>\r\n \t<li aria-level=\"1\">Master of Laws LLM with Placement Year</li>\r\n \t<li aria-level=\"1\">Master of Laws LLM with Work Experience</li>\r\n \t<li aria-level=\"1\">MA Global Film and Television (Online)</li>\r\n \t<li aria-level=\"1\">MA Journalism &amp; Media Communications</li>\r\n \t<li aria-level=\"1\">MA Journalism and Media Communications with Placement Year</li>\r\n \t<li aria-level=\"1\">MA Journalism and Media Communications with Advanced Research</li>\r\n \t<li aria-level=\"1\">MA Public Relations and Digital Communications</li>\r\n \t<li aria-level=\"1\">MA Public Relations and Digital Communications with Placement Year</li>\r\n \t<li aria-level=\"1\">MA Public Relations and Digital Communications with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc Audio Engineering</li>\r\n \t<li aria-level=\"1\">MA Creative Music Production</li>\r\n \t<li aria-level=\"1\">MSc Music and Sound for Film and Games</li>\r\n \t<li aria-level=\"1\">MSc Astrophysics</li>\r\n \t<li aria-level=\"1\">MSc Astrophysics with Placement Year</li>\r\n \t<li aria-level=\"1\">MSc Astrophysics with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc Data Science</li>\r\n \t<li aria-level=\"1\">MSc Theoretical Physics</li>\r\n \t<li aria-level=\"1\">MSc Theoretical Physics with Advanced Research</li>\r\n \t<li aria-level=\"1\">MSc Business Psychology</li>\r\n \t<li aria-level=\"1\">PgDip Cognitive Behavioural Therapy</li>\r\n \t<li aria-level=\"1\">MSc Cognitive Behavioural Therapy (Top-Up)</li>\r\n \t<li aria-level=\"1\">MSc Occupational Psychology</li>\r\n \t<li aria-level=\"1\">MSc Psychology</li>\r\n \t<li aria-level=\"1\">MSc Psychology (Conversion) (Online)</li>\r\n \t<li aria-level=\"1\">MSc Research in Clinical Psychology</li>\r\n \t<li aria-level=\"1\">MSc Social and Organisational Psychology (Online)</li>\r\n \t<li aria-level=\"1\">MSc Strength, Conditioning and Rehabilitation</li>\r\n</ul>\r\n<a href=\"https://www.herts.ac.uk/courses/postgraduate-masters-study\" target=\"_blank\" rel=\"noopener\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/uniofherts/\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://x.com/UniofHerts?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor\" target=\"_blank\" rel=\"noopener\">\r\nTwitter\r\n</a>\r\n<a href=\"https://www.instagram.com/uniofherts/?hl=en\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/channel/UClNSRsYQKCn0QqCa219Cqhg\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.herts.ac.uk/\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.herts.ac.uk/international/guidance-for-your-region/americas/usa\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.herts.ac.uk/international/scholarships-and-fees/fees\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.herts.ac.uk/international/scholarships-and-fees/scholarships\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.herts.ac.uk/international/guidance-for-your-region/americas/usa#:~:text=You%20can%20apply%20online%20from,Student%20Aid%20Report%20(SAR).\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.herts.ac.uk/study/open-days-and-events/undergraduate-events/online-events\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.herts.ac.uk/research\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.herts.ac.uk/international/coming-to-the-uk/accommodation\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.herts.ac.uk/life/supporting-your-career\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.herts.ac.uk/life\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"https://www.herts.ac.uk/international/apply\" target=\"_blank\" rel=\"noopener\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"University of Hertfordshire","post_link":"https://theukstudyexpert.com/universities/university-of-hertfordshire/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Hertfordshire\" width=\"300\" height=\"169\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/12/hertford-white-logo-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"Business Economics, Creativeperforming Arts Design, Education, Engineering, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"4","taxonomy=category":"Universities","taxonomy=post_tag":"Business Economics, Creativeperforming Arts Design, Education, Engineering, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"Hertfordshire, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":18033,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Falmouth University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Falmouth University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Untitled-design-9-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/falmouth-university/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Falmouth University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Falmouth University, a top UK creative university in Cornwall, offers industry-aligned programs in Art, Architecture, Design, Gaming, Media, Fashion, Film, Photography and more. With TEF Silver teaching standards, Falmouth prepares students for successful creative careers.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Falmouth University, a top UK creative university in Cornwall, offers industry-aligned programs in Art, Architecture, Design, Gaming, Media, Fashion, Film, Photography and more. With TEF Silver teaching standards, Falmouth prepares students for successful creative careers.","address":"Treliever Rd, Penryn TR10 8RT, UK","location":{"lat":"50.1718279","state":"England","country":"United Kingdom","lng":"-5.1113181","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/falmouth-university/","zoom":5,"extra_fields":{"post_excerpt":"Falmouth University, a top UK creative university in Cornwall, offers industry-aligned programs in Art, Architecture, Design, Gaming, Media, Fashion, Film, Photography and more. With TEF Silver teaching standards, Falmouth prepares students for successful creative careers.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/1-6.png\" alt=\"Falmouth University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/1-11.png\" alt=\"Falmouth University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/1-9.png\" alt=\"Falmouth University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/1-8.png\" alt=\"Falmouth University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/1-7.png\" alt=\"Falmouth University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/1-10.png\" alt=\"Falmouth University\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact Falmouth University\r\n</a>\r\n\r\n<strong>Location:</strong> Penryn Campus, Treliever Road, Penryn TR10 9FE, UK\r\n\r\n<strong>Website:</strong> <a href=\"https://falmouth.ac.uk\">https://falmouth.ac.uk</a>\r\n<h3>Overview</h3>\r\nFalmouth University is one of the UK\u2019s top creative universities located in a beachside town of Cornwall, England. Falmouth is home to roughly 5,000 students from 53 countries all over the world and offers a range of creative courses that include Art, Architecture, Design, Gaming, Media, Film, Fashion, Photography, Performance, Journalism and Writing. Our world-class, industry-standard facilities and our hands-on approach, help students prepare for life after graduation.\r\n\r\nFalmouth University\u2019s degrees are focused on the specific subject areas and closely aligned with industry, so students tackle live briefs, work in industry-standard facilities and are taught by academics who are professionals in their field. Our graduates have gone on to become everything from games designers to choreographers, documentary makers and fine artists. With more than 100 years\u2019 experience, TEF Silver teaching, professional facilities, peerless connections and a vibrant creative community, we\u2019re not afraid to do things differently. We\u2019re re-thinking the shape of higher education and delivering impactful research and innovation.\r\n\r\nCornwall is famous for its cultural scene and Falmouth is right at the heart of it. The region is now home to one of the most diverse, eclectic and exciting festival scenes in the UK, boasting major music festivals as well as film and literature festivals. Music, theatre, dance and comedy can also be found in venues big and small. Our two stunning campuses are set in beautiful gardens, equipped with world-class facilities and offer great spaces for learning and socialising.\r\n\r\n<strong>Population:\u00a0</strong>4,664\r\n\r\n<strong>Campus Type: </strong>Town\r\n<h3>Quick Facts</h3>\r\n<ul>\r\n \t<li>Rated Silver in the Teaching Excellence Framework (TEF)</li>\r\n \t<li>Ranked among the best in the UK for arts, design, and media, Falmouth University offers leading programs in creative industries.</li>\r\n \t<li>The campus includes world-class resources like AMATA, the Design Centre, and the Institute of Photography for hands-on learning.</li>\r\n \t<li>Recognized with a \"Green Flag\" award, the University prioritizes eco-friendly practices and sustainability.</li>\r\n \t<li>Falmouth University\u2019s career-focused programs connect students with industry through professional placements and support for entrepreneurship.</li>\r\n \t<li>Known for its outstanding student support, the University offers comprehensive mental health, career, and academic resources.</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://www.youtube.com/watch?v=gPz6e_VPf1chttps://www.youtube.com/watch?v=KACWkz2w7HQhttps://www.youtube.com/watch?v=i9aHRlRiqaIhttps://www.youtube.com/watch?v=kzRwZXvV0tshttps://www.youtube.com/watch?v=RIly-f_Ge_whttps://www.youtube.com/watch?v=36EN_fFSs1w&amp;t=28s\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nSuccessful completion of the USA High School Diploma.\r\n\r\nSAT/ACT tests and AP exams are NOT required.\r\n\r\nPortfolio and Interview are required.\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n<ul>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Acting</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Animation</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Architecture</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business and Digital Marketing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business and Entrepreneurship</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Business and Management</li>\r\n \t<li aria-level=\"1\">Business and Marketing (online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Commercial Photography</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computer Science</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Computing for Games</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Costume Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Advertising</li>\r\n \t<li aria-level=\"1\">Creative Music Technology</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Writing (online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Dance and Choreography</li>\r\n \t<li aria-level=\"1\">Document and Editorial Photography</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Drawing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">English and Creative Writing</li>\r\n \t<li aria-level=\"1\">Esports and Livestreaming</li>\r\n \t<li aria-level=\"1\">Events Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Fashion Marketing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Fashion Photography</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Fashion Styling and Art Direction</li>\r\n \t<li aria-level=\"1\">Festival Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Film</li>\r\n \t<li aria-level=\"1\">Film and Television Production</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Fine Art</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Game Animation</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Game Development Art</li>\r\n \t<li aria-level=\"1\">Game Development Design</li>\r\n \t<li aria-level=\"1\">Game Development Programming</li>\r\n \t<li aria-level=\"1\">Game Development Writing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Graphic Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Illustration (online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Interior Design (online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Journalism and Creative Writing</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Marine and Natural History Photography</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Marketing Communications</li>\r\n \t<li aria-level=\"1\">Media Production</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Musical Theatre</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Photography (online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Popular Music</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Product Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Robotics</li>\r\n \t<li aria-level=\"1\">Software Engineering</li>\r\n \t<li aria-level=\"1\">Sound Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sustainable Festival management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sustainable Product Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Sustainable Tourism Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Technical theatre arts</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Textile design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Theatre and Performance</li>\r\n \t<li aria-level=\"1\">Visual Communications (online)</li>\r\n</ul>\r\n<a href=\"https://www.falmouth.ac.uk/study/undergraduate\" target=\"_blank\" rel=\"noopener\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nGood honours Bachelor's degree or relevant experience (APEL).\r\n\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n<ul>\r\n \t<li>Artificial Intelligence for Games</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Comedy Writing (Online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Communication Design</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Advertising</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Creative Events Management (Online)</li>\r\n \t<li aria-level=\"1\">Entrepreneurship and Innovation Management</li>\r\n \t<li aria-level=\"1\">Feature Filmmaking</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Film &amp; Television (Online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Fine Art (Online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Game Art</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Game Design</li>\r\n \t<li aria-level=\"1\">Game Programming</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Graphic Design (Online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Illustration (Online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Illustration: Authorial Practice</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Indie Game Development (Online)</li>\r\n \t<li aria-level=\"1\">International Business Management</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Journalism (Online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Marketing and Digital Communications (Online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Music Business</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Photography</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Post Graduate Certificate in Higher Education (Online)</li>\r\n \t<li aria-level=\"1\">Professional Writing (Online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Prosthetic Effects</li>\r\n \t<li aria-level=\"1\">Sustainable Fashion (Online)</li>\r\n \t<li aria-level=\"1\">User Experience Design (Online)</li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"1\">Writing for Script &amp; Screen (Online)</li>\r\n</ul>\r\n<a href=\"https://www.falmouth.ac.uk/study/postgraduate\" target=\"_blank\" rel=\"noopener\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/falmouthuni/\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://twitter.com/FalmouthUni?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor\" target=\"_blank\" rel=\"noopener\">\r\nTwitter\r\n</a>\r\n<a href=\"https://www.instagram.com/falmouthuni/?hl=en\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/user/FalmouthUniversity\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.falmouth.ac.uk/about\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.falmouth.ac.uk/study/international/\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.falmouth.ac.uk/study/tuition-fees\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.falmouth.ac.uk/study/student-funding/scholarships-for-international-students\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.falmouth.ac.uk/study/international/us-federal-loans\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.falmouth.ac.uk/experience/virtual-experience\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.falmouth.ac.uk/research\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.falmouth.ac.uk/accommodation\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.falmouth.ac.uk/employability\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.falmouth.ac.uk/news/clubs-societies-falmouth-university\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"https://www.falmouth.ac.uk/apply\" target=\"_blank\" rel=\"noopener\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"Falmouth University","post_link":"https://theukstudyexpert.com/universities/falmouth-university/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Falmouth University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Untitled-design-9-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"Business Economics, Creativeperforming Arts Design, England, Humanities, Technology Computer Science","%_custom_priority_meta_key%":"4","taxonomy=category":"Universities","taxonomy=post_tag":"Business Economics, Creativeperforming Arts Design, England, Humanities, Technology Computer Science","city_country":"Cornwall, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":17799,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"University of Exeter","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Exeter\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Untitled-design-4-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/university-of-exeter/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Exeter</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Founded in 1851 and a proud member of the Russell Group, the University of Exeter is recognized for excellence in teaching and research, holding a Gold award from the Teaching Excellence Framework. The University of Exeter offers over 40 subject areas with more than 30,000 students from around the world.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Founded in 1851 and a proud member of the Russell Group, the University of Exeter is recognized for excellence in teaching and research, holding a Gold award from the Teaching Excellence Framework. The University of Exeter offers over 40 subject areas with more than 30,000 students from around the world.","address":"Exeter EX4 4TH, UK","location":{"lat":"50.734688","state":"England","country":"United Kingdom","lng":"-3.535685","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/university-of-exeter/","zoom":5,"extra_fields":{"post_excerpt":"Founded in 1851 and a proud member of the Russell Group, the University of Exeter is recognized for excellence in teaching and research, holding a Gold award from the Teaching Excellence Framework. The University of Exeter offers over 40 subject areas with more than 30,000 students from around the world.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Untitled-design-2.jpg\" alt=\"University of Exeter\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Untitled-design-3-1.jpg\" alt=\"University of Exeter\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Untitled-design-4-1.jpg\" alt=\"University of Exeter\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Untitled-design-5-1.jpg\" alt=\"University of Exeter\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Untitled-design-6-1.jpg\" alt=\"University of Exeter\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Untitled-design-7-1.jpg\" alt=\"University of Exeter\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact University of Exeter\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> The Queen's Drive, Exeter EX4 4QJ United Kingdom</p><p><strong>Website:</strong> <a href=\"https://exeter.ac.uk\" target=\"_blank\" rel=\"noopener\">https://exeter.ac.uk</a></p><h3>Overview</h3><p>The University of Exeter offers 3 year Bachelors, 1 year Masters and PhD programmes in 40 different subject areas across humanities and arts, social sciences, STEM and business. The University is rated Gold in the Teaching Excellence Framework and a member of the research-led Russell Group of universities, recognising our excellent reputation for teaching, research and student experience. We are a UK Top 15 University with World Top 50 subjects including English, Environmental and Marine Sciences and Sport-related subjects plus 21 UK Top 10 subjects including Drama and Film, Business, History and Psychology.<br /><br /></p><p>Located in the beautiful South West of England and just over 2 hours from London by train, our university campuses in the city of Exeter and the coastal town of Penryn are surrounded by outstanding sandy beaches and stunning national parks and countryside.\u00a0<br /><br /></p><p>The University offers excellent graduate prospects and career support and has superb links with hundreds of international, national and regional employers. Many of our programmes offer study abroad and/or work placement opportunities. With more than 400 clubs and societies and consistently in the top 5 of the British Universities and Colleges Sports League, students can get involved with numerous extracurricular activities relating to their studies, home country, hobbies and interests.<br /><br /></p><p>We currently have over 30,000 students of which 7,000 are international, including more than 200 students from the US, making for a really vibrant and inclusive academic community. Scholarships are offered across a range of undergraduate and postgraduate programmes.</p><p><br style=\"font-weight: 400;\" /><strong>Population:\u00a0</strong>30,000</p><p><strong>Campus Type: </strong>Suburban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul><li><p>Located just over 2 hours from London, Exeter is a UNESCO city of literature and our campuses, in the beautiful South West of England, are surrounded by outstanding sandy beaches and stunning national parks</p></li><li>UK Top 15 university with 21 subjects in the UK Top 10</li><li>40 subject areas across humanities and arts, social sciences, STEM and business</li><li>Member of the Russell Group of leading research-intensive universities and rated Gold in the Teaching Excellence Framework</li><li>Top 10 most targeted UK university by the Times Top 100 Graduate Employers</li><li>Consistently Top 5 in the BUCS (British University and Colleges Sport) league</li><li>UK Business School of the Year (Times Higher Education Awards 2022)</li><li>\u2018University of the Year\u2019 runner-up in the Times and Sunday Times \u2018Good University Guide 2024\u2019</li><li>Scholarships are offered across a range of undergraduate and postgraduate programmes</li></ul>\t\t\n\t\t<h3>Videos</h3>https://youtu.be/ehUEDj43zVwhttps://www.youtube.com/watch?v=BUN0sSa2e9chttps://youtu.be/Vz8nTXFL1lc?si=nwMT0meWFx-7m0jchttps://youtu.be/Yq8JHDspgMw?si=474hidfSuomQZ7vH\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p>We require the equivalent of three UK A levels \u2013 undergraduate students from the US can typically meet this by successfully completing their High School Diploma with a combination of the following options:</p><p>\u00a0</p><ul><li>Advanced Placement tests (APs) - typically ranging from 444 to 555, depending on programme</li><li>ACT (composite score) - typically ranging from 28 to 32</li><li>College level class credit (at least three units/credits or one semester in length) - B grade or above</li><li>High school honours class credit (at least one year's duration; year 11 or 12) - B grade or above</li></ul><p>These options can be 'mixed and matched' to meet our standard 3 x A level requirements. For example, you may have one Advanced Placement test, one High School honours class and one College-level class.</p><p><br />Please note however, that any subject-specific A level requirements can only be met by any of the following:</p><p>\u00a0</p><ul><li>A relevant Advanced Placement Test grade</li><li>Appropriate College-level class credit<br /></li></ul><p><br />For subject-specific requirements, please see the relevant page of our undergraduate courses.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<ul><li>Accounting and Finance</li><li>Anthropology</li><li>Arab and Islamic Studies</li><li>Archaeology</li><li>Art History &amp; Visual Culture</li><li>Biomedical and Medical Sciences</li><li>Biosciences</li><li>Business and Management</li><li>Classics and Ancient History</li><li>Computer Science</li><li>Criminology</li><li>Data Science</li><li>Drama</li><li>Earth Sciences</li><li>Ecology and Conservation</li><li>Economics</li><li>Engineering</li><li>English</li><li>Environmental Humanities</li><li>Environmental Science</li><li>Film Studies</li><li>Flexible Combined Honours</li><li>Geography</li><li>Geology</li><li>History</li><li>Law</li><li>Liberal Arts</li><li>Mathematics</li><li>Media and Communications</li><li>Medical Imaging (Diagnostic Radiography)</li><li>Medicine</li><li>Mining Engineering</li><li>Modern Languages and Cultures</li><li>Natural Sciences</li><li>Neuroscience</li><li>Nursing</li><li>Philosophy</li><li>Physics and Astronomy</li><li>Politics and International Relations</li><li>Psychology</li><li>Renewable Energy</li><li>Sociology</li><li>Sport and Health Sciences</li><li>Theology and Religion</li></ul>\n\t\t\t<a href=\"https://www.exeter.ac.uk/study/undergraduate/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>Students are typically required to hold a relevant Bachelor's degree with a grade equivalent to a UK Second-class honours (2:1 or 2:2); please check the relevant page of our Masters courses for the exact entry requirements of your chosen course.</p><p>We would typically use the following equivalencies:</p><p>\u00a0</p><ul><li>UK Upper Second class honours (2:1) = US 3.2+ / 4.0 GPA</li><li>UK Lower Second class honours (2:2) = US 2.6+ / 4.0 GPA</li></ul>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<ul><li>Accounting</li><li>Anthropology</li><li>Arab and Islamic Studies</li><li>Archaeology</li><li>Biosciences</li><li>Business and Management</li><li>Classics and Ancient History</li><li>Climate Change</li><li>Computer Science</li><li>Creative Industries</li><li>Data Science and Analytics</li><li>Drama</li><li>Ecology and Conservation</li><li>Economics</li><li>Education and Teacher Training</li><li>Engineering</li><li>English</li><li>Film</li><li>Finance</li><li>Geography</li><li>Geology</li><li>Healthcare and Medicine</li><li>History</li><li>Law</li><li>Mathematics</li><li>Media and Communications</li><li>Mining Engineering</li><li>Modern Languages and Cultures</li><li>Philosophy</li><li>Physics and Astronomy</li><li>Politics and International Relations</li><li>Psychology</li><li>Renewable Energy Engineering</li><li>Security Studies</li><li>Sociology</li><li>Sport and Health Sciences</li><li>Theology and Religion</li></ul>\n\t\t\t<a href=\"https://www.exeter.ac.uk/study/postgraduate/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"https://www.facebook.com/exeteruni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://x.com/uniofexeter\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.instagram.com/uniofexeter/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.youtube.com/@universityofexeter/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"http://www.exeter.ac.uk\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.exeter.ac.uk/study/international/entry/usa/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.exeter.ac.uk/study/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.exeter.ac.uk/study/funding/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.exeter.ac.uk/students/finance/studentfunding/federalaidforusstudents/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.exeter.ac.uk/study/undergraduate/visit/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.exeter.ac.uk/research/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.exeter.ac.uk/study/accommodation/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.exeter.ac.uk/students/careers/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.exeter.ac.uk/study/life/thestudentsunion/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"https://www.exeter.ac.uk/study/undergraduate/applying/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"University of Exeter","post_link":"https://theukstudyexpert.com/universities/university-of-exeter/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Exeter\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Untitled-design-4-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"4","taxonomy=category":"Universities","taxonomy=post_tag":"Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"Exeter, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":17778,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"University of Strathclyde","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Strathclyde Glasgow\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/09/Untitled-design-2-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/university-of-strathclyde/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Strathclyde</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                The University of Strathclyde is Scotland\u2019s third largest university. We are a truly global university providing cutting-edge education to more than 30,000 students from over 140 different countries around the world.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"The University of Strathclyde is Scotland\u2019s third largest university. We are a truly global university providing cutting-edge education to more than 30,000 students from over 140 different countries around the world.","address":"16 Richmond St, Glasgow G1 1XQ, UK","location":{"lat":"55.8619473","state":"Scotland","country":"United Kingdom","lng":"-4.2423246","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/university-of-strathclyde/","zoom":5,"extra_fields":{"post_excerpt":"The University of Strathclyde is Scotland\u2019s third largest university. We are a truly global university providing cutting-edge education to more than 30,000 students from over 140 different countries around the world.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Strathclyde.png\" alt=\"University of Strathclyde\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Strathclyde-1.png\" alt=\"University of Strathclyde\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Strathclyde-2.png\" alt=\"University of Strathclyde\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact University of Strathclyde\r\n</a>\r\n\r\n<strong>Location:</strong>\u00a016 Richmond Street, Glasgow, Scotland, G1 1XQ, United Kingdom\r\n\r\n<strong>Website:</strong>\u00a0<a href=\"https://www.strath.ac.uk/\" rel=\"noopener\">https://strath.ac.uk/</a>\r\n<h3>Overview</h3>\r\nThe University of Strathclyde is Scotland\u2019s third largest university. We are a truly global university providing cutting-edge education to more than 30,000 students from over 140 different countries around the world.\r\n\r\nOriginally founded in 1796 as a place of useful learning, we\u2019re a leading technological University offering a wide range of fields of study.\r\n\r\nWe have over 200 undergraduate degree and a further 200 Postgraduate Degrees programs across 4 Faculties: Business (our Business School is triple accredited including AACSB), Engineering, Humanities &amp; Social Sciences and Science.\r\n\r\n<strong>Population:\u00a0</strong>30,000\r\n\r\n<strong>Campus Type:\u00a0</strong>Urban\r\n<h3>Quick Facts</h3>\r\n<ul data-rte-list=\"default\">\r\n \t<li>Located in the heart of Glasgow, Scotland\u2019s largest and friendliest city.</li>\r\n \t<li>30,000 students from over 140 countries</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://www.youtube.com/watch?v=Q8N3GLMzx4chttps://www.youtube.com/watch?v=bsypQ47E3TQhttps://www.youtube.com/watch?v=HgpwCXUfeishttps://www.youtube.com/watch?v=bdxx0ol93Dg\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nWe have a test-flexible admissions policy for US students. We invite interested students to submit their application directly or through UCAS for their chosen course, along with their current or completed high school diploma, which we will consider with a minimum 3.0 GPA.\r\n\r\nCandidates are invited to submit any standardized testing, and we will consider the following:\r\n<ul>\r\n \t<li>SAT: 1200 (600 in each component)/ ACT: 27 plus 2 AP exams with scores of 4+OR</li>\r\n \t<li>3 AP exams with scores of 4+</li>\r\n</ul>\r\nWhere candidates do not have access to or have not taken standardized testing, we will consider strong academic performance demonstrated within the high school diploma, for example AP or Honors classes.\r\n\r\nEntry to some degree programmes may require the completion of AP classes or exams, or Honors classes with grades A/B in specific subjects eg Calculus and Physics for Engineering.\r\n\r\nPlease contact the academic department or International Office if you are not sure.\r\n\r\nWe do not superscore the SAT or consider the optional essay.\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n\r\nBA Hons Accounting\r\nBA Hons Accounting &amp; Business Analysis and Technology\r\nBA Hons Accounting &amp; Business Enterprise\r\nBA Accounting &amp; Business Law\r\nBA Accounting &amp; Economics\r\nBA Joint Hons Accounting &amp; Finance\r\nBA Hons Accounting &amp; Hospitality and Tourism Management\r\nBA Joint Hons Accounting &amp; Human Resource Management\r\nBA Accounting &amp; Marketing\r\nMEng Aero-Mechanical Engineering\r\nBEng Aero-Mechanical Engineering\r\nMSci Applied Chemistry &amp; Chemical Engineering\r\nBSc Hons Architectural Studies\r\nMSci Biochemistry\r\nBSc Hons Biochemistry &amp; Immunology\r\nBSc Hons Biochemistry &amp; Microbiology\r\nBSc Hons Biochemistry &amp; Pharmacology\r\nBEng Biomedical Engineering\r\nMEng Biomedical Engineering\r\nBSc Hons Biomedical Science\r\nBSc Hons Biomolecular Sciences\r\nBA Hons Business\r\nBBA Hons Business Administration\r\nBA Hons Business Analysis &amp; Technology\r\nBA Hons Business Analysis and Technology &amp; Business Enterprise\r\nBA Hons Business Analysis and Technology &amp; Business Law\r\nBA Hons Business Analysis and Technology &amp; Economics\r\nBA Hons Business Analysis and Technology &amp; Finance\r\nBA Hons Business Analysis and Technology &amp; Hospitality and Tourism Management\r\nBA Hons Business Analysis and Technology &amp; Human Resource Management\r\nBA Hons Business Analysis and Technology &amp; Marketing\r\nBA Hons Business Analysis and Technology &amp; Mathematics and Statistics\r\nBA Hons Business Enterprise\r\nBA Hons Business Enterprise &amp; Business Law\r\nBA Hons Business Enterprise &amp; Economics\r\nBA Hons Business Enterprise &amp; Finance\r\nBA Hons Business Enterprise &amp; Hospitality and Tourism Management\r\nBA Hons Business Enterprise &amp; Human Resource Management\r\nBA Hons Business Enterprise &amp; Marketing\r\nBEng Chemical Engineering\r\nMEng Chemical Engineering\r\nMChem Chemistry\r\nMChem Chemistry with Data Science\r\nMChem Chemistry with Drug Discovery\r\nMChem Chemistry with Teaching\r\nMEng Civil &amp; Environmental Engineering\r\nBEng Civil &amp; Environmental Engineering\r\nMEng Civil Engineering\r\nBEng Civil Engineering\r\nMEng Computer &amp; Electronic Systems\r\nBEng Computer &amp; Electronic Systems\r\nMEng Computer &amp; Electronic Systems with International Study\r\nMEng Computer Science\r\nBSc Hons Computer Science\r\nBSc Hons Data Analytics\r\nBA Hons Economics\r\nBA Hons Economics &amp; Business Law\r\nBA Hons Economics &amp; Finance\r\nBA Joint Hons Economics &amp; Human Resource Management\r\nBA Joint Hons Economics &amp; Marketing\r\nBA Economics &amp; Psychology\r\nBA Joint Hons Economics, Mathematics &amp; Statistics\r\nBA Hons Education &amp; Economics\r\nBA Hons Education &amp; English\r\nBA Hons Education &amp; English and Creative Writing\r\nBA Hons Education &amp; French\r\nBA Hons Education &amp; History\r\nBA Hons Education &amp; Human Resource Management\r\nBA Hons Education &amp; Journalism, Media and Communication\r\nBA Hons Education &amp; Law\r\nBA Hons Education &amp; Politics and International Relations\r\nBA Hons Education &amp; Psychology\r\nBA Hons Education &amp; Social Policy\r\nBA Hons Education &amp; Spanish\r\nMEng Electrical &amp; Mechanical Engineering\r\nBEng Hons Electrical &amp; Mechanical Engineering\r\nMEng Electrical &amp; Mechanical Engineering with International Study\r\nMEng Electrical Energy Systems\r\nMEng Electronic &amp; Digital Systems\r\nBEng Hons Electronic &amp; Electrical Engineering\r\nMEng Electronic &amp; Electrical Engineering\r\nMEng Electronic &amp; Electrical Engineering with Business Studies\r\nMEng Electronic &amp; Electrical Engineering with International Study\r\nBA Hons English\r\nBA Hons English &amp; Creative Writing\r\nBA Joint Hons English &amp; French\r\nBA Joint Hons English &amp; History\r\nBA Joint Hons English &amp; Human Resource Management\r\nBA Hons English &amp; Journalism, Media and Communication\r\nBA Joint Hons English &amp; Law\r\nBA Joint Hons English &amp; Politics and International Relations\r\nBA Joint Hons English &amp; Psychology\r\nBA Hons English &amp; Social Policy\r\nBA Joint Hons English &amp; Spanish\r\nBA Hons English and Creative Writing &amp; French\r\nBA Hons English and Creative Writing &amp; History\r\nBA Hons English and Creative Writing &amp; Human Resource Management\r\nBA Hons English and Creative Writing &amp; Journalism, Media and Communication\r\nBA Hons English and Creative Writing &amp; Law\r\nBA Hons English and Creative Writing &amp; Politics and International Relations\r\nBA Hons English and Creative Writing &amp; Psychology\r\nBA Hons English and Creative Writing &amp; Social Policy\r\nBA Hons English and Creative Writing &amp; Spanish\r\nBA Hons Finance\r\nBA Hons Finance &amp; Business Law\r\nBA Hons Finance &amp; Hospitality and Tourism Management\r\nBA Joint Hons Finance &amp; Human Resource Management\r\nBA Joint Hons Finance &amp; Marketing\r\nBA Joint Hons Finance &amp; Mathematics and Statistics\r\nMChem Forensic &amp; Analytical Chemistry\r\nBA Hons French &amp; Economics\r\nBA Joint Hons French &amp; History\r\nBA Hons French &amp; Hospitality and Tourism Management\r\nBA Joint Hons French &amp; Human Resource Management\r\nBA Hons French &amp; Journalism, Media and Communication\r\nBA Joint Hons French &amp; Law\r\nBA Joint Hons French &amp; Marketing\r\nBA Hons French &amp; Politics and International Relations\r\nBA Joint Hons French &amp; Psychology\r\nBA Hons French &amp; Social Policy\r\nBA Joint Hons French &amp; Spanish\r\nBA Hons History\r\nBA Hons History &amp; Economics\r\nBA Joint Hons History &amp; Human Resource Management\r\nBA Hons History &amp; Journalism, Media and Communication\r\nBA Joint Hons History &amp; Law\r\nBA Joint Hons History &amp; Politics and International Relations\r\nBA History &amp; Psychology\r\nBA Hons History &amp; Social Policy\r\nBA Joint Hons History &amp; Spanish\r\nBA Hons Hospitality &amp; Tourism Management\r\nBA Hons Hospitality and Tourism Management &amp; Business Law\r\nBA Hons Hospitality and Tourism Management &amp; Human Resource Management\r\nBA Hons Hospitality and Tourism Management &amp; Marketing\r\nBA Hons Human Resource Management\r\nBA Hons Human Resource Management &amp; Business Law\r\nBA Joint Hons Human Resource Management &amp; Marketing\r\nBA Joint Hons Human Resource Management &amp; Psychology\r\nMSci Immunology\r\nBSc Hons Immunology &amp; Microbiology\r\nBSc Hons Immunology &amp; Pharmacology\r\nBA Hons International Business\r\nMBus International Business with a Modern Language\r\nBA Hons Journalism, Media and Communication &amp; Economics\r\nBA Hons Journalism, Media and Communication &amp; Human Resource Management\r\nBA Hons Journalism, Media and Communication &amp; Law\r\nBA Hons Journalism, Media and Communication &amp; Politics and International Relations\r\nBA Hons Journalism, Media and Communication &amp; Psychology\r\nBA Hons Journalism, Media and Communication &amp; Social Policy\r\nBA Hons Journalism, Media and Communication &amp; Spanish\r\nLLB Law\r\nBA Hons Law &amp; Economics\r\nBA Hons Law &amp; Human Resource Management\r\nBA Hons Law &amp; Politics and International Relations\r\nBA Joint Hons Law &amp; Psychology\r\nBA Hons Law &amp; Social Policy\r\nBA Joint Hons Law &amp; Spanish\r\nLLB Law (Clinical) (Graduate Entry)\r\nLLB Law (Graduate Entry)\r\nLLB Hons Law with French\r\nLLB Hons Law with Spanish\r\nMEng Manufacturing Engineering with Management\r\nBEng Hons Manufacturing Engineering with Management\r\nBA Hons Marketing\r\nBA Hons Marketing &amp; Business Law\r\nBA Joint Hons Marketing &amp; Psychology\r\nBSc Mathematics\r\nMMath Mathematics\r\nBSc Hons Mathematics &amp; Computer Science\r\nBSc Hons Mathematics &amp; Physics\r\nBSc Hons Mathematics with Teaching\r\nBSc Hons Mathematics, Statistics &amp; Accounting\r\nBSc Hons Mathematics, Statistics &amp; Business Analysis\r\nBSc Hons Mathematics, Statistics &amp; Economics\r\nBSc Hons Mathematics, Statistics &amp; Finance\r\nBEng Hons Mechanical Engineering\r\nMEng Mechanical Engineering\r\nBEng Hons Mechanical Engineering with International Study\r\nMEng Mechanical Engineering with International Study\r\nMSci Microbiology\r\nBSc Hons Microbiology &amp; Pharmacology\r\nBEng Hons Naval Architecture &amp; Marine Engineering\r\nMEng Naval Architecture &amp; Marine Engineering\r\nMEng Naval Architecture with High Performance Marine Vehicles\r\nBeng Hons Naval Architecture with High Performance Marine Vehicles\r\nBEng Hons Naval Architecture with Ocean Engineering\r\nMEng Naval Architecture with Ocean Engineering\r\nMSci Pharmacology\r\nMPharm Pharmacy\r\nBSc Hons Physics\r\nMPhys Physics\r\nMPhys Physics with Advanced Research\r\nBSc Hons Physics with Teaching\r\nBA Hons Politics &amp; International Relations\r\nBA Hons Politics and International Relations &amp; Economics\r\nBA Hons Politics and International Relations &amp; Human Resource Management\r\nBA Hons Politics and International Relations &amp; Psychology\r\nBA Hons Politics and International Relations &amp; Social Policy\r\nBA Hons Politics and International Relations &amp; Spanish\r\nBA Hons Primary Education\r\nMSci Product Design &amp; Innovation\r\nBSc Hons Product Design &amp; Innovation\r\nMEng Product Design Engineering\r\nBEng Hons Product Design Engineering\r\nBSc Hons Prosthetics &amp; Orthotics\r\nBA Hons Psychology\r\nBSc Hons Psychology &amp; Counselling\r\nBA Hons Psychology &amp; Economics\r\nBA Hons Psychology &amp; Human Resource Management\r\nBA Joint Hons Psychology &amp; Mathematics\r\nBA Hons Psychology &amp; Social Policy\r\nBA Joint Hons Psychology &amp; Spanish\r\nBA Hons Social Policy &amp; Economics\r\nBA Hons Social Policy &amp; Human Resource Management\r\nBA Hons Social Policy &amp; Spanish\r\nBA Hons Social Work\r\nBSc Hons Software Engineering\r\nBA Hons Spanish &amp; Economics\r\nBA Hons Spanish &amp; Hospitality and Tourism Management\r\nBA Hons Spanish &amp; Human Resource Management\r\nBA Joint Hons Spanish &amp; Marketing\r\nBSc Hons Speech &amp; Language Pathology\r\nBSc Hons Sport &amp; Physical Activity\r\nMEng Sports Design Engineering\r\nBEng Hons Sports Design Engineering\r\n\r\n<a href=\"https://www.strath.ac.uk/courses/undergraduate/\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nA minimum GPA of 3.0 or above on a 4.0 scale. Some courses may accept a lower GPA and will take into consideration your supporting documents. Please contact us if you are in any doubt. Applications are made directly to Strathclyde through the course web page for postgraduate study. If you wish to apply for a research degree you\u2019d normally have to have a Masters degree and some experience of research work.\r\n\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n\r\n5G Advanced Communications\r\nActuarial Science\r\nMArch Advanced Architectural Design\r\nAdvanced Biochemistry\r\nAdvanced Chemical &amp; Process Engineering (distance learning)\r\nAdvanced Chemical Engineering\r\nAdvanced Chemical Engineering (January intake)\r\nAdvanced Computer Science\r\nAdvanced Computer Science (January start)\r\nAdvanced Computer Science with Artificial Intelligence\r\nAdvanced Computer Science with Data Science\r\nAdvanced Computer Science with Data Science (January start)\r\nAdvanced Computer Science with Software Engineering\r\nAdvanced Computer Science with Software Engineering (January start)\r\nAdvanced Construction Technologies &amp; BIM\r\nAdvanced Construction Technologies and BIM (January)\r\nAdvanced Drug Delivery\r\nAdvanced Electrical Power &amp; Energy Systems\r\nAdvanced Immunology\r\nAdvanced Manufacturing: Technology &amp; Systems\r\nAdvanced Materials Engineering\r\nAdvanced Mechanical Engineering\r\nAdvanced Mechanical Engineering (January intake)\r\nAdvanced Mechanical Engineering (Online Learning)\r\nAdvanced Mechanical Engineering with Aerospace\r\nAdvanced Mechanical Engineering with Aerospace (January intake)\r\nAdvanced Mechanical Engineering with Energy Systems\r\nAdvanced Mechanical Engineering with Energy Systems (January)\r\nAdvanced Mechanical Engineering with Industrial Placement\r\nAdvanced Mechanical Engineering with Materials\r\nAdvanced Naval Architecture\r\nAdvanced Naval Architecture (January)\r\nAdvanced Pharmaceutical Manufacturing\r\nAdvanced Pharmacology\r\nAdvanced Physics\r\nApplied Economics\r\nApplied Economics (Online)\r\nApplied Educational &amp; Social Research\r\nApplied Gender Studies\r\nApplied Physics\r\nApplied Statistics\r\nApplied Statistics (online)\r\nApplied Statistics in Finance\r\nApplied Statistics in Finance (online)\r\nApplied Statistics in Health Sciences\r\nApplied Statistics in Health Sciences (online)\r\nApplied Translation\r\nApplied Translation &amp; Interpreting\r\nMArch Architectural Design (International)\r\nArchitectural Design for the Conservation of Built Heritage\r\nArtificial Intelligence &amp; Applications\r\nAutism\r\nAutonomous Robotic Intelligent Systems\r\nBiomedical Engineering\r\nBiomedical Engineering (January intake)\r\nBiomedical Sciences\r\nBusiness &amp; Management\r\nBusiness &amp; Management (January)\r\nBusiness Analysis &amp; Consulting\r\nBusiness Analysis &amp; Consulting (January)\r\nCancer Therapies\r\nChemical Technology &amp; Management (Distance Learning)\r\nChemistry with Artificial Intelligence\r\nChemistry with Data Science\r\nChild &amp; Youth Care Studies by Distance Learning\r\nChildren &amp; Young People in Conflict with the Law\r\nCivil Engineering\r\nCivil Engineering (January intake)\r\nClinical Health Psychology\r\nClinical Pharmacy\r\nConstruction Law\r\nCounselling &amp; Psychotherapy\r\nCreative Writing\r\nCriminal Justice &amp; Penal Change\r\nCrimonology &amp; Social Policy\r\nCyber Security\r\nData Analytics\r\nData Science for Politics &amp; Policymaking\r\nDesign Engineering\r\nDesign Engineering with Advanced Product Development\r\nDesign Engineering with Sustainability\r\nDigital Health Systems\r\nDigital Journalism\r\nDigital Manufacturing\r\nDigital Marketing Management\r\nDigital Marketing Management (January)\r\nDiplomacy &amp; International Security\r\nEarly Years Pedagogue\r\nEconomics &amp; Finance\r\nEconomics &amp; Policy of Energy &amp; Climate Change\r\nEconomics &amp; Policy of Energy &amp; Climate Change (Online)\r\nEducation (international)\r\nEducation (international) (January)\r\nEducation Studies\r\nEducation Studies (January)\r\nEducational Leadership\r\nElectrical Power &amp; Energy Systems\r\nElectronic &amp; Electrical Engineering\r\nEnergy Systems Innovation\r\nEngineering Management for Process Excellence\r\nEngineering Project Management (Online)\r\nEntrepreneurship Engineering &amp; Technology\r\nEnvironemental Engineering\r\nEnvironemental Engineering (January Intake)\r\nEnvironemental Engineering (Distance Learning)\r\nFinance\r\nFinance (January)\r\nFinancial Technology\r\nForensic Science\r\nGlobal Environmental Law &amp; Governance\r\nHealth &amp; Social Policy\r\nHealth Analysis, Policy &amp; Management\r\nHealth History\r\nHistorical Studies\r\nHuman Resource Management\r\nHuman Resource Management (part-time)\r\nHuman Rights Law\r\nHydrogeology\r\nHydrogeology (Online)\r\nIndustrial Biotechnology\r\nInformation &amp; Library Studies\r\nInformation Management\r\nInterdisciplinary English Studies\r\nInternational Accounting &amp; Finance\r\nInternational Accounting &amp; Finance (January)\r\nInternational Banking &amp; Finance\r\nInternational Commercial Law\r\nInternational Commercial Law (January)\r\nInternational Human Resource Management\r\nInternational Management\r\nInternational Management (January)\r\nInternational Marketing\r\nInternational Master Project Management\r\nInternational Relations\r\nInternational Relations (January)\r\nInternational Social Welfare\r\nInvestment &amp; Finance\r\nInvestment &amp; Finance (January)\r\nLaw\r\nLaw (January)\r\nLaw, Technology &amp; Innovation\r\nMachine Learning &amp; Deep Learning\r\nMachine Learning &amp; Deep Learning (January)\r\nMarine Engineering\r\nMarine Engineering (January)\r\nMarine Engineering with Specialisation in Autonomous Marine Vehicles\r\nMarketing\r\nMarketing (January)\r\nMaster of Business Administration (MBA)\r\nMBA with Specialisation in Sustainable Energy Futures\r\nMechatronics &amp; Automation\r\nMechatronics &amp; Automation (January)\r\nMedia &amp; Communication\r\nMedia &amp; Communication (January)\r\nMedia &amp; Conflict Resolution\r\nMolecular Microbiology\r\nNanoscience\r\nNeuroscience &amp; Mental Health\r\nOffshore Wind Energy\r\nPharmaceutical Analysis\r\nPhotonics\r\nPolitical Economy\r\nPolitical Research\r\nPolitics\r\nPsotgraduate Diploma in Primary Education (PGDE)\r\nProcess Technology &amp; Management (Distance Learning)\r\nProduct Design\r\nProfessional Legal Practice\r\nProject Management &amp; Innovation\r\nProsthetics &amp; Orthotics\r\nProsthetics &amp; Orthotics Rehabilitation Studies\r\nPsychology with Specialisation in Business or Health\r\nPublic Policy\r\nPublic Policy (January)\r\nQuantitative Finance\r\nQuantum Technologies\r\nRenewable Energy and Decqrbonisation Technologies\r\nResearch Methods in Psychology\r\nSattelite Data for Sustainable Development (January)\r\nShip and Offshore Structures\r\nShip and Offshore Structures (January)\r\nSmart Grids with the Comillas Pontifical University, Madrid\r\nSocial Policy\r\nSocial Policy (Research Methods)\r\nSocial Work\r\nSoftware Development\r\nSport Data Analytics\r\nSubsea &amp; Pipeline Engineering\r\nSubsea &amp; Pipeline Engineering (January)\r\nSupply Chain &amp; Logistics Management\r\nSupply Chain &amp; Logistics Management (January)\r\nSupply Chain &amp; Procurement Management\r\nSupply Chain &amp; Procurement Management (January)\r\nSupply Chain &amp; Sustainability Management\r\nSupply Chain &amp; Sustainability Management (January)\r\nSustainabilty\r\nSustainability &amp; Environmental Studies\r\nSustainability &amp; Environmental Studies (January)\r\nSustainability &amp; Environmental Studies (Online)\r\nSustainable Engineering: Chemical Processing\r\nSustainable Engineering: Chemical Processing (January)\r\nSustainable Engineering: Marine Technology\r\nSustainable Engineering: Marine Technology (January)\r\nSustainable Engineering: Offshore Renewable Energy\r\nSustainable Engineering: Offshore Renewable Energy (January)\r\nSustainable Engineering: Renewable Energy Systems &amp; the Environment\r\nSustainable Finance\r\nSystems Engineering Management\r\nTechnical Ship Management\r\nTechnical Ship Management (January)\r\nTechnology Policy &amp; Management\r\nTESOL Intercultural Communication\r\nTESOL Intercultural Communication (January)\r\nTourism Marketing Management\r\nUrban Design\r\nUrban Policy &amp; Analysis\r\nWind Energy Systems\r\nWork &amp; Organisational Psychology\r\n\u201c\r\nPhD, Mphil Accounting &amp; finance\u201d\r\nPhD, MPhil Applied Linguistics\r\nPhD, Mphil, MRes Architecture\r\nMRes Biofluid mechanics\r\nMres, Mphil, PhD Biomedical engineering\r\nPhD, MPhil Chemical &amp; process engineering\r\nMPhil, PhD Chemistry\r\nPhD, Mphil, MRes Civil &amp; environmental engineering\r\nPhD, MPhil Computer &amp; information sciences\r\nMPhil/ PhD Counselling\r\nPhD, MPhil, MRes Creative writing\r\nPhD Criminology\r\n\u201c\r\nPhD, MPhil, EngD, Industrial Doctorate Design, manufacturing &amp; engineering management\u201d\r\nDInfSci Doctor of Information Science\r\nMphil, PhD Economics\r\nMphil, PhD Education\r\nEdD Education\r\nDEdPsy Educational Psychology\r\n\u201c\r\nMPhil, PhD, EngD &amp; Industrial Doctorate Electronic &amp; electrical engineering\u201d\r\nPhD, Mphil, MRes English\r\nPhD Entrepreneurship, Innovation &amp; Strategy\r\nPhD Gender Studies\r\nPhD, MPhil, MRes History\r\nPhD History with Genealogical Studies\r\nPhD, Mphil, MRes Journalism, Media &amp; Communication\r\nPhD, MPhil Law\r\nMphil, PhD Management science\r\nPhD, MPhil Marketing\r\nPhD, Mphil, MRes Mathematics &amp; statistics\r\nMPhil, PhD Mechanical &amp; aerospace engineering\r\nPhD, Mphil, MRes Modern languages\r\nPhD, MPhil, EngD, MRes Naval architecture, ocean &amp; marine engineering\r\nPhD, MPhil Pharmacy &amp; biomedical sciences\r\nPhD, MPhil, MRes Physical activity and health\r\nPhD, MPhil, MRes Physics\r\nPhD, MPhil Politics\r\nMphil, PhD, DEdPsy Psychology\r\nPhD Public Health &amp; Health Policy\r\nMRes Research Methodology for Business &amp; Management\r\nPhD, MPhil Social work &amp; social policy\r\nMRes Speech &amp; Language Sciences\r\nPhD, MPhil Speech &amp; language therapy\r\nPhD Translation Studies\r\nPhD, MRes Work, employment &amp; organisation\r\n\r\n<a href=\"https://www.strath.ac.uk/studywithus/postgraduatetaught/\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/UniversityOfStrathclyde/\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://x.com/unistrathclyde\" target=\"_blank\" rel=\"noopener\">\r\nTwitter\r\n</a>\r\n<a href=\"https://www.instagram.com/unistrathclyde/\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/unistrathclyde\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.strath.ac.uk/\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.strath.ac.uk/studywithus/internationalstudents/northlatinamerica/\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.strath.ac.uk/studywithus/feesfunding/tuitionfees/\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.strath.ac.uk/studywithus/scholarships/\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.strath.ac.uk/professionalservices/finance/studentfinances/usdirectfederalloan/\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://news.strath.ac.uk/p/2XTA-7TE/study-at-the-university-of-strathclyde-americas?pfredir=1\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.strath.ac.uk/studywithus/postgraduateresearchphdopportunities/\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.strath.ac.uk/studywithus/accommodation/\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.strath.ac.uk/professionalservices/careers/\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.strath.ac.uk/studywithus/ourcampus/whatsoncampus/faithspiritualitysupport/clubssocietiesandgroups/\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"https://google.com/\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"University of Strathclyde","post_link":"https://theukstudyexpert.com/universities/university-of-strathclyde/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Strathclyde Glasgow\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/09/Untitled-design-2-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"3.0, 3.1, 3.2, 3.3+, Business Economics, Education, Engineering, Health Medicine, Humanities, Life Physical Sciences, Scotland, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"4","taxonomy=category":"Universities","taxonomy=post_tag":"3.0, 3.1, 3.2, 3.3+, Business Economics, Education, Engineering, Health Medicine, Humanities, Life Physical Sciences, Scotland, Social Science, Technology Computer Science","city_country":"Glasgow, Scotland"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":17625,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"University of Greenwich","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Greenwich\" width=\"300\" height=\"154\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/05/Untitled-design-79-e1723567215811-300x154.webp\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/greenwich/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Greenwich</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                The University of Greenwich, London, is driven by a founding ethos of \u2018no limits\u2019. Our fundamental vision is to empower everyone to explore new possibilities, unbound by conventional wisdom and artificial boundaries. \r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"The University of Greenwich, London, is driven by a founding ethos of \u2018no limits\u2019. Our fundamental vision is to empower everyone to explore new possibilities, unbound by conventional wisdom and artificial boundaries. ","address":"Old Royal Naval College, Park Row, London SE10 9LS, UK","location":{"lat":"51.4829866","state":"England","country":"United Kingdom","lng":"-0.0063883","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/greenwich/","zoom":5,"extra_fields":{"post_excerpt":"The University of Greenwich, London, is driven by a founding ethos of \u2018no limits\u2019. Our fundamental vision is to empower everyone to explore new possibilities, unbound by conventional wisdom and artificial boundaries. ","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Greenwich.png\" alt=\"University of Greenwich\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Greenwich-1.png\" alt=\"University of Greenwich\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Greenwich-2.png\" alt=\"University of Greenwich\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Greenwich-3.png\" alt=\"University of Greenwich\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Greenwich-4.png\" alt=\"University of Greenwich\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Greenwich-5.png\" alt=\"University of Greenwich\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact University of Greenwich\r\n</a>\r\n\r\n<strong>Location:</strong> Old Royal Naval College, Park Row, SE10 9LS\r\n\r\n<strong>Website:</strong> <a href=\"https://www.gre.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://gre.ac.uk/</a>\r\n<h3>Overview</h3>\r\nThe University of Greenwich, London, is driven by a founding ethos of \u2018no limits\u2019. Our fundamental vision is to empower everyone to explore new possibilities, unbound by conventional wisdom and artificial boundaries. Voted by StudentCrowd as the Number 1 University in London and by WhatUni Student Choice as the Number 1 University in London for international students, the University of Greenwich is a lively and diverse community of people united by their passion for learning. As a multi-faculty university, we offer a range of courses, designed in conjunction with business, industry and technology to prepare you for the next stage of your career. We have a comprehensive range of support services for all our students, including scholarships and a Wellbeing Hub, and we\u2019re also one of the few London universities that has everything you need in one place. Teaching, social, sports and living spaces are all on campus or nearby.\r\n\r\n<strong>Population: </strong>30,000\r\n\r\n<strong>Campus Type: </strong>Urban\r\n<h3>Quick Facts</h3>\r\n<ul data-rte-list=\"default\">\r\n \t<li>22,000+ international students from over 100 countries?</li>\r\n \t<li>Ranked No. 1 the best UK university by StudentCrowd Awards 2023</li>\r\n \t<li>Awarded Gold in the TEF 2023 awards</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://www.youtube.com/watch?v=r5TBd6YrGXohttps://www.youtube.com/watch?v=GJq1J28mqKQhttps://www.youtube.com/watch?v=ZsBJPaHnESY\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nWe are test optional for our Undergraduate courses. For standard entry, you will need to have the following:\r\n\r\nHigh School Diploma with a minimum GPA 3.2 or GED with a minimum grade of 175\r\n\r\nFor students with a GPA 2.8 or GED of 165, you will also need ONE of the following:\r\n<ul>\r\n \t<li>ACT - Grade 22 or above</li>\r\n \t<li>AP - Grade 3 or above in 2 advanced placement tests</li>\r\n \t<li>SAT - 1050 in SAT with minimum of 500 in each section (Post-March 2016) or 1650 (pre-March 2016)</li>\r\n</ul>\r\nIB - modules with a minimum points of 18\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n\r\nAgriculture (Final Year Entry) (Hadlow),BSc Hons\r\nAccounting and Business Analytics, BA Hons\r\nAccounting and Finance (Extended), BA Hons\r\nAccounting and Finance, BA Hons\r\nAccounting and Finance, BA Hons (Year 2 &amp; 3 Direct Entry)\r\nAdult Nursing (Medway), BSc Hons\r\nAdult Nursing, BSc Hons\r\nAdult Nursing, BSc Hons (Degree Apprenticeship)\r\nAnimal Management (Final Year Entry) (Hadlow), BSc Hons\r\nAnimation, BA Hons\r\nApplied Animal Behaviour and Welfare (Final Year Entry) (QA Only), BSc (Plumpton)\r\nApplied Animal Behavioural Science (Final Year Entry) (Hadlow), BSc Hons\r\nApplied Biomedical Science, BSc Hons\r\nAquaculture and Fisheries Management (Final Year Entry) (Hadlow), BSc Hons\r\nArchitecture, BA Hons\r\nBiology (Extended), BSc Hons\r\nBiology, BSc Hons\r\nBiology, MBiol\r\nBiomedical Science (Extended), BSc Hons\r\nBiomedical Science, BSc Hons\r\nBuilding Studies, HNC (London South East Colleges)\r\nBuilding Studies, HND (QA Only) (London South East Colleges)\r\nBuilding Surveying, HNC (London South East Colleges)\r\nBuilding Surveying, HND (QA Only) (London South East Colleges)\r\nBusiness Computing, BSc Hons\r\nBusiness Economics, BA Hons\r\nBusiness Entrepreneurship and Innovation, BA Hons\r\nBusiness Logistics and Supply Chain Management (Year 2 &amp; 3 Direct Entry), BA Hons\r\nBusiness Logistics and Supply Chain Management, BA Hons\r\nBusiness Management (Extended), BA Hons\r\nBusiness Management (Year 2 &amp; 3 Entry), BA Hons\r\nBusiness Management and Leadership, BA Hons\r\nBusiness Management, BA Hons\r\nBusiness Psychology, BSc Hons\r\nBusiness Studies (Year 2 &amp; 3 Direct Entry), BA Hons\r\nBusiness Studies, BA Hons\r\nBusiness with Accounting (Year 3 Direct Entry), BA Hons\r\nBusiness with Finance (Year 2 &amp; 3 Direct Entry), BA Hons\r\nBusiness with Finance, BA Hons\r\nBusiness with Marketing (Year 2 &amp; 3 Direct Entry), BA Hons\r\nBusiness with Marketing, BA Hons\r\nCertificate of Higher Education in Sports Coaching, CertHE\r\nChemical Engineering (Extended), BEng Hons\r\nChemical Engineering with Industrial Practice, BEng Hons\r\nChemical Engineering, BEng Hons\r\nChemical Engineering, MEng\r\nChemistry (Extended), BSc Hons\r\nChemistry, BSc Hons\r\nChemistry, BSc Hons (Degree Apprenticeship)\r\nChildren\u2019s Nursing, BSc Hons\r\nChildren\u2019s Nursing, BSc Hons (Degree Apprenticeship)\r\nCivil Engineering (Extended), BEng Hons\r\nCivil Engineering (Royal School of Military Engineering), BEng (Hons)\r\nCivil Engineering, BEng Hons\r\nCivil Engineering, MEng\r\nComputer Engineering (Extended), BEng Hons\r\nComputer Engineering, BEng Hons\r\nComputer Engineering, MEng\r\nComputer Science (Artificial Intelligence), BSc Hons\r\nComputer Science (Cyber Security), BSc Hons\r\nComputer Science (Data Science), BSc Hons\r\nComputer Science (Games), BSc Hons\r\nComputer Science (Networking), BSc Hons\r\nComputer Science, BSc Hons\r\nComputing (Artificial Intelligence), BSc Hons\r\nComputing (Information Systems), BSc Hons\r\nComputing (Network Systems), BSc Hons\r\nComputing for Emerging Technologies, BSc Hons\r\nComputing, BSc Hons\r\nComputing, BSc Hons (Extended)\r\nConstruction Design and Build Technician, CertHE\r\nConstruction Management, BSc Hons\r\nConstruction Management, BSc Hons (Degree Apprenticeship)\r\nConstruction Management, HNC (London South East Colleges)\r\nConstruction Site Supervisor, CertHE\r\nCreative Advertising and Art Direction, BA Hons\r\nCreative Writing and English Literature, BA Hons\r\nCreative Writing, BA Hons\r\nCriminology and Criminal Justice, BA Hons\r\nCriminology and Criminal Psychology (Extended), BSc Hons\r\nCriminology and Criminal Psychology, BSc Hons\r\nCyber Security and Digital Forensics, BSc Hons\r\nCybernetics (Extended), BEng Hons\r\nCybernetics, BEng Hons\r\nCybernetics, MEng\r\nData Science, BSc Hons\r\nDigital Marketing and Advertising, BA Hons\r\nDigital and Technology Solutions, BSc Hons (Degree Apprenticeship)\r\nDrama and English Literature with International Study, BA Hons\r\nDrama and English Literature, BA Hons\r\nDrama with International Study, BA Hons\r\nDrama, BA Hons\r\nEarly Years, BA Hons\r\nEarly Years, BA Hons (Top-up)\r\nEconomics (Year 2 &amp; 3 Direct Entry), BSc Hons\r\nEconomics, BSc Hons\r\nEducation Studies (Final Year Entry) (North Kent College \u2013 Tonbridge)\r\nEducation Studies, BA Hons (Top up) (NESCOT)\r\nElectrical Engineering (Royal School of Military Engineering), BEng (Hons)\r\nElectrical and Electronic Engineering (Extended), BEng Hons\r\nElectrical and Electronic Engineering Technology, BEng Hons\r\nElectrical and Electronic Engineering, BEng Hons\r\nElectrical and Electronic Engineering, MEng\r\nEmbedded Electronic Systems Design and Development, BEng Hons\r\nEmbedded Electronic Systems Design and Development, BEng Hons (Degree Apprenticeship)\r\nEngineering Management (Extended), BEng Hons\r\nEngineering Management, BEng Hons\r\nEngineering Manufacturing Technician, CertHE\r\nEngineering, Design and Innovation (Extended), BEng Hons\r\nEngineering, Design and Innovation, BEng Hons\r\nEnglish Language and Literature, BA Hons\r\nEnglish Language and TESOL, BA Hons\r\nEnglish Literature with Creative Writing, BA Hons\r\nEnglish Literature, BA Hons\r\nEquine Training and Management (Final Year Entry) (Hadlow), BSc Hons\r\nEvents Management and Innovation, BA Hons\r\nFilm Studies, BA Hons\r\nFilm and Television Production, BA Hons\r\nFinance and Investment Banking, BSc Hons\r\nFinance and Investment Banking, BSc Hons (Year 2 &amp; 3 Direct Entry)\r\nFinancial Mathematics, BSc Hons\r\nFood Science &amp; Nutrition, BSc Hons\r\nFood and Drink Engineer, DipHE\r\nForensic Science (Extended), BSc Hons\r\nForensic Science with Criminology (Extended), BSc Hons\r\nForensic Science with Criminology and Industrial Placement, BSc Hons\r\nForensic Science with Criminology, BSc Hons\r\nForensic Science with Industrial Placement, BSc Hons\r\nForensic Science, BSc Hons\r\nForensic Toxicology, BSc Hons\r\nForensic and Digital Investigation with Industrial Placement, BSc Hons\r\nForensic and Digital Investigation, BSc Hons\r\nFurther Education and Skill Sector,Prof Cert Ed (FE) (QA Only) (NESCOT)\r\nGames Development, BSc Hons\r\nGraduate Diploma Enhanced Clinical Practice (Apprenticeship)\r\nGraphic and Digital Design, BA Hons\r\nGraphic and Digital Design, HND\r\nHealth and Social Care, BA Hons (Top-up)\r\nHistory and English, BA Hons\r\nHistory and Politics, BA Hons\r\nHistory and Sociology, BA Hons\r\nHistory, BA Hons\r\nHorticulture (Commercial) (Final Year Entry) (Hadlow), BSc Hons\r\nHospitality Management (Year 2 &amp; 3 Direct Entry), BA Hons\r\nHospitality Management, BA Hons\r\nHuman Nutrition &amp; Health (Extended), BSc Hons\r\nHuman Nutrition &amp; Health, BSc Hons\r\nHuman Resource Management, BA Hons\r\nInternational Business with Language, BA Hons\r\nInternational Business, BA Hons\r\nInternational Wine Business (QA only), BA (Plumpton College)\r\nLandscape Architecture, BA Hons\r\nLanguages and International Relations, BA Hons\r\nLaw (Extended), LLB Hons\r\nLaw Senior Status, LLB Hons\r\nLaw in Practice, LLB Hons\r\nLaw with Criminology, LLB Hons\r\nLaw, LLB Hons\r\nLearning Disabilities Nursing, BSc Hons\r\nLearning Disabilities Nursing, BSc Hons (Degree Apprenticeship)\r\nMarketing and Brand Management, BA Hons\r\nMathematics and Computer Science, BSc Hons\r\nMathematics, BSc Hons\r\nMechanical Engineering (Extended), BEng Hons\r\nMechanical Engineering Technology, BEng Hons\r\nMechanical Engineering, BEng Hons\r\nMechanical Engineering, MEng\r\nMechanical and Building Services Engineering (Royal School of Military Engineering), BEng (Hons)\r\nMedia and Communications, BA Hons\r\nMental Health Nursing, BSc Hons\r\nMental Health Nursing, BSc Hons (Degree Apprenticeship)\r\nMidwifery (Avery Hill), BSc Hons\r\nMidwifery (Degree Apprenticeship)\r\nMidwifery (Medway), BSc Hons\r\nMusic and Sound Production, BA Hons\r\nOccupational Safety, Health and Environment, BSc Hons (Top-up)\r\nOperating Department Practitioner, BSc Hons\r\nOperating Department Practitioner, BSc Hons (Degree Apprenticeship)\r\nParamedic Science, BSc Hons\r\nPharmaceutical Sciences (Extended), BSc Hons\r\nPharmaceutical Sciences, BSc Hons\r\nPharmaceutical Sciences, BSc Hons (Degree Apprenticeship)\r\nPharmacy, MPharm\r\nPhysical Education and Sport, BA Hons\r\nPhysiotherapy, BSc Hons\r\nPolitics and International Relations, BA Hons\r\nPrimary Education Studies (2-Year Accelerated Degree), BA Hons\r\nPrimary Education with QTS (5-11), BA Hons\r\nProfessional Certificate in Education (Further Education &amp; Skills) (NESCOT) (QA)\r\nProfessional Certificate in Education (Further Education and Training)\r\nProfessional Dance and Musical Theatre, BA Hons\r\nPsychology (Extended), BSc Hons\r\nPsychology with Counselling, BSc Hons\r\nPsychology, BSc Hons\r\nPublic Health (Extended), BSc Hons\r\nPublic Health, BSc Hons\r\nQuantity Surveying, BSc Hons\r\nQuantity Surveying, BSc Hons (Degree Apprenticeship)\r\nQuantity Surveying, HNC (London South East Colleges)\r\nQuantity Surveying, HND (QA Only) (London South East Colleges)\r\nRural Land and Business Management (QA only), BSc (Plumpton College)\r\nSocial Work, BA Hons\r\nSociology and Criminology, BSc Hons\r\nSociology and Psychology, BSc Hons\r\nSociology, BA Hons\r\nSoftware Engineering, BEng Hons\r\nSpecialist Community Public Health Nursing (Health Visiting and School Nursing), BSc Hons (Top-up)\r\nSpecialist Practitioner (District Nursing), BSc Hons (Top up)\r\nSpeech and Language Therapy, BSc Hons\r\nSport and Exercise Science, BSc\r\nStatistics and Data Analytics, BSc Hons\r\nStudy Abroad, LLB Hons\r\nSustainable Agriculture (QA only), BSc (Plumpton College)\r\nTourism Management with Language, BA Hons\r\nTourism Management, BA Hons\r\nViticulture and Oenology (QA only), BSc (Plumpton College)\r\n\r\n<a href=\"https://www.gre.ac.uk/undergraduate-courses/a-z\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nFor entry to our Master's programmes, you will need to have met the following:\r\n<ul>\r\n \t<li>For a course requesting a UK 2:2 -\u00a0 Bachelor degree with a minimum GPA 2.8<strong>OR</strong></li>\r\n \t<li>For a course requesting a UK 2:1 - Bachelor degree with a minimum GPA 3.0</li>\r\n</ul>\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n\r\nData Science and its Applications (Medway), MSc\r\nAccounting and Finance, MPhil/PhD\r\nAccounting and Finance, MSc\r\nAdvanced Chemical Engineering with Industrial Practice, MSc\r\nAdvanced Chemical Engineering, MSc\r\nAdvanced Clinical Practice, MSc\r\nAdvanced Clinical Practitioner, MSc (Degree Apprenticeship)\r\nAgriculture for Sustainable Development, MSc\r\nApplied Artificial Intelligence for Engineering, MSc\r\nApplied Criminology, MA\r\nApplied Food Safety and Quality Management with Industrial Practice, MSc\r\nApplied Food Safety and Quality Management, PGDip/MSc\r\nApplied Linguistics, MA\r\nArchitectural Practice, PGDip (ARB/RIBA Part 3 Exemption)\r\nArchitecture Part 2, MArch\r\nArchitecture, Landscape and Urbanism, MSc\r\nAward of Institutional Credit in Learning and Teaching in Higher Education\r\nBig Data and Business Intelligence, MSc\r\nBiomedical Science, MSc/PGDip/PGCert\r\nBiotechnology, MSc\r\nBuilt Environment, MPhil/PhD\r\nBusiness Analytics, MSc\r\nBusiness, MPhil/PhD\r\nChild and Adolescent Psychology, MSc\r\nCivil Engineering with Industrial Practice, MSc\r\nCivil Engineering, MSc\r\nComputer Forensics and Cyber Security, MSc\r\nComputer Science (Network Engineering), MSc\r\nComputer Science, MPhil/PhD\r\nComputer Science, MSc\r\nComputing and Information Systems, MSc\r\nComputing and Mathematical Sciences, MSc by Research\r\nConstruction Management and Economics, MSc\r\nConstruction Project Management, MSc\r\nCreative Writing, MA\r\nCriminology and Criminal Psychology, MSc\r\nCriminology, Gender and Sexualities, MSc\r\nData Science (FinTech), MSc\r\nData Science and its Applications, MSc\r\nData Science, MSc\r\nDesign, MA\r\nDevelopment Studies \u2013 Research, MPhil/PhD\r\nDigital Arts, MA\r\nDigital Marketing Management, MSc\r\nDoctorate in Education, EdD\r\nEconomics, MPhil/PhD\r\nEconomics, MSc\r\nEducation and Training, MPhil/PhD\r\nEducation, MA\r\nEducation, MPhil/PhD\r\nElectrical Power Engineering with Industrial Practice, MSc\r\nElectrical Power Engineering, MSc\r\nElectrical and Electronic Engineering with Industrial Practice, MSc\r\nElectrical and Electronic Engineering, MSc\r\nEngineering \u2013 Research, MPhil/PhD\r\nEngineering Management with Industrial Practice, MSc\r\nEngineering Management, MSc\r\nEngineering, MSc by Research\r\nEnglish Literature, MA\r\nEnhanced Professional Practice, PGDip\r\nExecutive Master of Business Administration, MBA\r\nFacilities Management, MSc\r\nFilm Production, MA\r\nFinance and Investment, MSc\r\nFinance, MBA\r\nFinancial Management and Risk, MSc\r\nFintech and Finance, MSc\r\nFood Innovation with Industrial Practice, MSc\r\nFood Innovation, MSc\r\nFood Safety and Quality Management e-learning, PGCert/PGDip/MSc\r\nForensic Psychology, MSc\r\nFormulation Science, MSc\r\nGeneral Pharmacy Practice, PGCert/PGDip/MSc\r\nGlobal Environmental Change, MSc\r\nGlobal Health Management, MSc\r\nGlobal Public Health MSc\r\nGlobal Shipping Management, MSc\r\nGlobal Sustainable Development, MSc\r\nHaematology, MSc/PGDip/PGCert\r\nHealth Sciences, MPhil/PhD\r\nHealthcare Management, MSc/PGDip/PGCert\r\nHealthcare Practice, MA\r\nHealthcare Quality Management, MSc/PGDip/PGCert\r\nHigher Education, PGCert\r\nHuman Resource Management, MA\r\nHuman Resources and Organisational Behaviour, MPhil/PhD\r\nHuman Sciences, MPhil/PhD\r\nIndependent/Supplementary Prescribing, PGCert\r\nInternational &amp; Commercial Law, LLM\r\nInternational Banking and Finance, MSc\r\nInternational Business, MA\r\nInternational Business, MA (Dual Award, Greenwich and New Zealand)\r\nInternational Events Management, MA\r\nInternational Postgraduate Certificate in Education (Online)\r\nInternational Relations, MA\r\nInternational Tourism and Hospitality Management, MA\r\nInterprofessional Healthcare Simulation, MSc\r\nLandscape Architecture, MA\r\nLandscape Architecture, MLA\r\nLaw, Regulation and the International Financial System, MSc\r\nLogistics and Supply Chain Management, MA\r\nManagement of Business Information Technology, MSc\r\nMarketing Management, MA\r\nMarketing Management, MBA\r\nMathematical Sciences, MPhil/PhD\r\nMechanical and Manufacturing Engineering with Industrial Practice, MSc\r\nMechanical and Manufacturing Engineering, MSc\r\nMedia and Creative Cultures, MA\r\nMedicines Optimisation, PGCert/PGDip/MSc\r\nMusic and Sound Design, MA\r\nNatural Resources, MSc (by Research)\r\nNursing (Adult Nursing), MSc\r\nNursing (Children\u2019s Nursing), MSc\r\nNursing (Learning Disabilities Nursing), MSc\r\nNursing (Mental Health Nursing), MSc\r\nOccupational Hygiene, MSc\r\nOccupational Psychology, MSc\r\nPharmaceutical Science, MSc/PGDip\r\nPharmaceutical Sciences with Industrial Practice, MSc\r\nPost Graduate Certificate in Education (Further Education and Training)\r\nPostgraduate Certificate in Education (Further Education &amp; Skills) (NESCOT) (QA)\r\nPrimary Education (3-11) (Provider-led School-based) with QTS, PGCE\r\nPrimary Education (3-11) (Provider-led University-based) with QTS, PGCE\r\nProduct Design Engineering, MSc\r\nProfessional Graduate Certificate in Education (Further Education &amp; Skills) (NESCOT) (QA)\r\nProfessional Graduate Certificate in Education (Further Education and Training)\r\nPsychology, MSc (Conversion Degree)\r\nReal Estate Development and Investment, MSc\r\nReal Estate, MSc\r\nSafety, Health and Environment, MSc\r\nScience \u2013 Research, MPhil/PhD\r\nScience, MSc by Research\r\nSecondary PGCE (11-19) (Provider-led School-based) with QTS\r\nSecondary PGCE with QTS (11-19) (Provider-led) (Mathematics)\r\nSecondary PGCE with QTS (11-19) (Provider-led) (Physical Education)\r\nSecondary PGCE with QTS (11-19) (Provider-led) (Science with Biology)\r\nSecondary PGCE with QTS (11-19) (Provider-led) (Science with Chemistry)\r\nSecondary PGCE with QTS (11-19) (Provider-led) (Science with Physics)\r\nSenior Leader Apprenticeship\r\nSocial Work, PGDip\r\nSocial Work, PGDip/MA\r\nSpecial Educational Needs: Leading Effective and Inclusive Practice (National Award for Special Educational Needs Coordination), PGCert\r\nSpecialist Community Public Health Nursing (Health Visiting and School Nursing), PGDip\r\nSpecialist Practitioner (District Nursing), PGDip\r\nSport and Exercise Psychology, MSc\r\nStrategic Marketing, MA (Dual Award)\r\nStrength and Conditioning, MSc\r\nSustainable Building Design and Engineering, MSc\r\nTherapeutic Counselling, MSc\r\nViticulture and Oenology (QA only), MSc (Plumpton College)\r\nWater, Waste and Environmental Engineering with Industrial Practice, MSc\r\nWater, Waste and Environmental Engineering, MSc\r\nWeb Design and Content Planning, MA\r\n\r\n<a href=\"https://www.gre.ac.uk/postgraduate-courses\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/uniofgreenwich/\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://x.com/UniofGreenwich?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor\" target=\"_blank\" rel=\"noopener\">\r\nX-twitter\r\n</a>\r\n<a href=\"https://www.instagram.com/uniofgreenwich/?hl=en\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/@UniversityGreenwich\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.gre.ac.uk/\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/international/countries/usa\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/international\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/bursaries/international-scholarships-award\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/finance/funding-your-studies/loans/federal-loans-for-usa-students\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.gre.ac.uk/events\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/research\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/accommodation\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/careers\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.greenwichsu.co.uk/\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"https://www.gre.ac.uk/study/apply/international\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"University of Greenwich","post_link":"https://theukstudyexpert.com/universities/greenwich/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Greenwich\" width=\"300\" height=\"154\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/05/Untitled-design-79-e1723567215811-300x154.webp\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"5","taxonomy=category":"Universities","taxonomy=post_tag":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"London, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":16826,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Edinburgh Napier University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Edinburgh Napier\" width=\"300\" height=\"145\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/Untitled-design-80-e1723220736832-300x145.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/edinburgh-napier-university/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Edinburgh Napier University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                We have more than 300 undergraduate and postgraduate courses and nearly 20,000 students from over 140 countries studying on campus in Edinburgh, online and at partner universities worldwide.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"We have more than 300 undergraduate and postgraduate courses and nearly 20,000 students from over 140 countries studying on campus in Edinburgh, online and at partner universities worldwide.","address":"9 Sighthill Ct, Edinburgh EH11 4BN, UK","location":{"lat":"55.9248537","state":"Scotland","country":"United Kingdom","lng":"-3.2887076","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/edinburgh-napier-university/","zoom":5,"extra_fields":{"post_excerpt":"We have more than 300 undergraduate and postgraduate courses and nearly 20,000 students from over 140 countries studying on campus in Edinburgh, online and at partner universities worldwide.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Edinburgh.png\" alt=\"Edinburgh Napier University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Edinburgh-1.png\" alt=\"Edinburgh Napier University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Edinburgh-2.png\" alt=\"Edinburgh Napier University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Edinburgh-3.png\" alt=\"Edinburgh Napier University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Edinburgh-4.png\" alt=\"Edinburgh Napier University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Edinburgh-5.png\" alt=\"Edinburgh Napier University\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact Edinburgh Napier University\r\n</a>\r\n\r\n<strong>Location:</strong> 9 Sighthill Ct., Edinburgh, Scotland, EH11 4BN, United Kingdom\r\n\r\n<strong>Website:</strong> <a href=\"https://www.napier.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://napier.ac.uk/</a>\r\n<h3>Overview</h3>\r\nA journey you'll remember!\r\n\r\nIt starts with travelling to a world-class university and goes wherever you want to take it.\r\n\r\nWe are Edinburgh Napier University, the #1 modern university in Scotland (Times Higher Education World University Rankings 2023), the #1 university in Edinburgh for student satisfaction (NSS 2020, 2021, 2022 &amp; 2023), a top 10 UK modern university (Times/Sunday Times Good University Guide 2023), and the top Scottish modern university for research power and impact (Research Excellence Framework 2021).\r\n\r\nWe pride ourselves on being the home of difference makers\u2014an enterprising and innovative community, renowned internationally, with an unrivalled student learning experience.\r\n\r\nWith more than 300 undergraduate and postgraduate courses and nearly 20,000 students from over 140 countries studying on campus in Edinburgh, online and at partner universities worldwide, we deliver meaningful, difference-making education and research for a rapidly changing world.\r\n\r\nAt Edinburgh Napier University, we\u2019re bold, ambitious and innovative. With strong industry links, we deliver a truly hands-on learning experience to ensure you\u2019re equipped with the skills and expertise to advance your knowledge and career.\r\nStart your journey today.\r\n\r\n<strong>Population: </strong>22,000\r\n\r\n<strong>Campus Type: </strong>Urban\r\n<h3>Quick Facts</h3>\r\n<ul data-rte-list=\"default\">\r\n \t<li>Top Scottish modern university for both research power and research impact</li>\r\n \t<li>Number 1 modern university in Scotland - THE World University Rankings 2023</li>\r\n \t<li>Number 1 university in Edinburgh for student satisfaction - National Student Survey 2023</li>\r\n \t<li>95% of our graduates are in work or further study 15 months after graduation</li>\r\n \t<li>Over 4,000 international students on campus from more than 140 countries</li>\r\n \t<li>Nearly 700 start-ups have been supported by our in-house business incubator</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://youtu.be/IVl_fulWWJohttps://youtu.be/TvZueMOujJE?si=pxWzhZFsJVN90WEXhttps://www.youtube.com/watch?v=4YubvDz9fAo\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nIn Scotland, undergraduate courses (called honours degrees) are designed to include four years of study, which is unique in the UK. Honours degrees offer enhanced flexibility and academic breadth.\r\n\r\nYou are eligible to apply if you received your High School Graduation Diploma with a GPA of 2.8 or above with one of the following:\r\n<ul>\r\n \t<li>SAT score of 1000 or higher with a minimum of 500 in each component</li>\r\n \t<li>ACT score of 24 or higher</li>\r\n \t<li>3 related Advanced Placement tests (AP's) with a grade of 4 or higher</li>\r\n</ul>\r\nIf you're applying with the GED, you are eligible if you have a pass in each of the 4 sections with a minimum score of 145/200 and an overall score of 580/800. You would need one of the 3 requirements above in addition.\r\n\r\nIf you're applying with an International Baccalaureate (IB), you are eligible if you have a minimum score of 26-30 in relevant subjects.\r\n\r\nIf you have attended a community college or would like to transfer to Edinburgh Napier, you may be considered for advanced entry into year 2 or 3 of a relevant degree course. Contact us to find out if you're eligible.\r\n\r\nEdinburgh Napier SAT institution code: 7894\r\n\r\nEdinburgh Napier ACT institution code: 3004\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n\r\nBSc (Hons) Animal &amp; Conservation Biology\r\nBSc (Hons) Applied Microbiology\r\nBSc (Hons) Biological Sciences\r\nBSc (Hons) Biomedical Science\r\nBSc (Hons) Marine &amp; Freshwater Biology\r\nBA (Hons) Business Management\r\nBA (Hons) Business Management with Entrepreneurship\r\nBA (Hons) Business Management with Human Resource Management\r\nBA (Hons) Business Management with Marketing\r\nBSc (Hons) Informatics for Business\r\nBA (Hons) International Business Management\r\nBSc (Hons) Architectural Technology\r\nBSc (Hons) Building Surveying\r\nBSc (Hons) Quantity Surveying\r\nBSc (Hons) Real Estate Surveying\r\nBEng (Hons) Computing\r\nBSc (Hons) Computer Science\r\nBSc (Hons) Computer Science (Artificial Intelligence)\r\nBEng (Hons) Computer Systems &amp; Networks\r\nBEng (Hons) Cybersecurity &amp; Forensics\r\nBSc (Hons) Data Science\r\nBSc (Hons) Digital Media &amp; Interaction Design\r\nBSc (Hons) Digital Media &amp; Interaction Design Global\r\nBSc (Hons) Games Development\r\nBSc (Hons) Informatics for Business\r\nBEng (Hons) Software Engineering\r\nMEng Software Engineering\r\nBSc (Hons) Sound Design\r\nBSc (Hons) User Experience (UX) Design\r\nBSc (Hons) Web Design &amp; Development\r\nBA (Hons) Criminology\r\nBSc (Hons) Policing &amp; Criminology\r\nBSc (Hons) Psychology\r\nBA (Hons) Psychology Sociology\r\nBA (Hons) Social Sciences\r\nBSc (Hons) Digital Media &amp; Interaction Design\r\nBDes (Hons) Graphic Design\r\nBDes (Hons) Interior &amp; Spatial Design\r\nBA (Hons) Photography\r\nBDes (Hons) Product Design\r\nBSc (Hons) Sound Design\r\nBSc (Hons) User Experience (UX) Design\r\nBEng (Hons) Civil Engineering\r\nMEng Civil Engineering\r\nMEng Civil &amp; Transportation Engineering\r\nBEng (Hons) Electrical &amp; Electronic Engineering\r\nMEng Electrical &amp; Electronic Engineering\r\nBEng (Hons) Energy &amp; Environmental Engineering\r\nBEng (Hons) Mechanical Engineering\r\nMEng Mechanical Engineering\r\nBSc (Hons) Digital Media &amp; Interaction Design\r\nBSc (Hons) Digital Media &amp; Interaction Design Global\r\nBA (Hons) English &amp; Film\r\nBA (Hons) Film\r\nBA (Hons) Journalism\r\nBA (Hons) Marketing with Digital Media\r\nBA (Hons) Mass Communications\r\nBA (Hons) Mass Communications, Advertising and Public Relations\r\nBA (Hons) Photography\r\nBA (Hons) Acting &amp; English\r\nBA (Hons) English\r\nBA (Hons) English &amp; Film\r\nLLB/LLB (Hons) Law\r\nBA (Hons) Business Management with Marketing\r\nBA (Hons) Marketing Management\r\nBA (Hons) Marketing with Digital Media\r\nBA (Hons) Music\r\nBSc (Hons) Football Coaching, Performance and Development\r\nBSc (Hons) Physical Activity &amp; Health\r\nBSc (Hons) Sport &amp; Exercise Science\r\nBSc (Hons) Sports Coaching\r\nBA (Hons) International Festival &amp; Event Management\r\nBA (Hons) International Hospitality Management\r\nBA (Hons) International Hospitality Management and Festival &amp; Events\r\nBA (Hons) International Tourism Management\r\nBA (Hons) International Tourism &amp; Airline Management\r\n\r\n<a href=\"https://www.napier.ac.uk/study-with-us/undergraduate\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nOur taught postgraduate degrees are one year in duration.\r\n\r\nYou are eligible to apply if you completed a bachelor degree with a minimum GPA of 2.7 or above.\r\n\r\nNo GRE/GMAT test scores are required.\r\n\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n\r\nMSc Accounting\r\n\r\nMFA Acting for Stage and Screen\r\n\r\nMSc Advanced Clinical Practice (named speciality)\r\n\r\nMFA Advanced Film Practice\r\n\r\nMSc Advanced Materials Engineering\r\n\r\nMSc Advanced Structural Engineering\r\n\r\nMSc Applied Criminology &amp; Forensic Psychology\r\n\r\nMSc Applied Forensic Psychology\r\n\r\nMSc Applied Social Research\r\n\r\nMSc Applied Sport Science\r\n\r\nMSc Architectural Technology &amp; Sustainable Building Performance\r\n\r\nMSc Automation and Control\r\n\r\nMSc Biomedical Science\r\n\r\nMSc Blended and Online Education\r\n\r\nPgDip Blended and Online Education\r\n\r\nPgCert Blended and Online Education\r\n\r\nMSc Business Analytics\r\n\r\nMSc Business Information Technology\r\n\r\nMSc Business Management\r\n\r\nMSc Business Management (Finance)\r\n\r\nMSc Business Management (Human Resource Management)\r\n\r\nMSc Business Management (Leadership &amp; Innovation)\r\n\r\nMSc Business Management (Logistics &amp; Supply Chains)\r\n\r\nMSc Business Management (Marketing)\r\n\r\nMSc Business Management (Project Management)\r\n\r\nMSc Business Management (Tourism &amp; Hospitality)\r\n\r\nPgDip Career Guidance &amp; Development\r\n\r\nMSc Clinical Exercise Physiology\r\n\r\nMSc Clinical Healthcare Technology\r\n\r\nMSc Computing\r\n\r\nMSc Computing with Professional Placement\r\n\r\nMSc Construction Project Management\r\n\r\nMSc Creative Advertising\r\n\r\nMA Creative Writing\r\n\r\nMSc Cyber Security\r\n\r\nMSc Data Engineering\r\n\r\nMA Design for Interactive Experience\r\n\r\nMSc Design Research\r\n\r\nMSc Digital Technologies for Smart Cities\r\n\r\nMFA Directing\r\n\r\nMSc Drug Design &amp; Biomedical Science\r\n\r\nMSc Environmental Sustainability\r\n\r\nPgCert Epilepsy Studies\r\n\r\nMSc Facilities Management\r\n\r\nMA Film\r\n\r\nMSc Global Hospitality Management\r\n\r\nMSc Global Logistics &amp; Supply Chain Analytics\r\n\r\nMSc Healthcare Management\r\n\r\nMA Heritage and Exhibition Design\r\n\r\nMSc Human Resource Management\r\n\r\nMSc Intercultural Business Communication\r\n\r\nMSc International Business Management\r\n\r\nMSc International Festival &amp; Event Management\r\n\r\nMSc International Finance\r\n\r\nMSc International Human Resource Management\r\n\r\nMSc International Marketing\r\n\r\nMSc International Marketing (Dual Degree)\r\n\r\nMSc International Tourism Destination Management\r\n\r\nMA Journalism\r\n\r\nMSc Marketing\r\n\r\nMSc Marketing with Digital Strategy\r\n\r\nMSc Marketing with Festival &amp; Event Management\r\n\r\nMBA MBA\r\n\r\nMBA MBA (Banking)\r\n\r\nMBA MBA (Business Leadership &amp; Practice)\r\n\r\nMBA MBA (Events Management)\r\n\r\nMBA MBA (Finance)\r\n\r\nMBA MBA (Health Management)\r\n\r\nMBA MBA (Hospitality &amp; Tourism Management)\r\n\r\nMBA MBA (Human Resource Management)\r\n\r\nMBA MBA (Information Systems Strategy &amp; Governance\r\n\r\nMBA MBA (Leadership &amp; Innovation)\r\n\r\nMBA MBA (Logistics and Supply Chain Management)\r\n\r\nMBA MBA (Marketing)\r\n\r\nMBA MBA (Project Management)\r\n\r\nMBA MBA (Strategic Project Management)\r\n\r\nMSc Medical Biotechnology\r\n\r\nMM Midwifery\r\n\r\nMA Music\r\n\r\nPgCert Neonatal Care: Qualified in Speciality\r\n\r\nMSc Nursing Adult Health\r\n\r\nMSc Nursing Mental Health\r\n\r\nMSc Occupational Therapy\r\n\r\nMSc Performance Enhancement in Sports Officiating\r\n\r\nMSc Pharmaceutical &amp; Analytical Science\r\n\r\nMSc Physiotherapy\r\n\r\nPGDE Professional Graduate Diploma in Education\r\n\r\nMPH Public Health\r\n\r\nMSc Publishing\r\n\r\nMSc Real Estate Management &amp; Investment\r\n\r\nMSc Renewable Energy\r\n\r\nMSc Robotics and Autonomous Systems Engineering\r\n\r\nMA Screenwriting\r\n\r\nMA Service Design\r\n\r\nMSW Social Work\r\n\r\nMSc Sound Design\r\n\r\nMA Sports Journalism\r\n\r\nPgCert Teaching and Supporting Learning in Higher Education\r\n\r\nMSc Transport Planning &amp; Engineering\r\n\r\nMSc User Experience Design\r\n\r\nMSc Wildlife Biology &amp; Conservation\r\n\r\nMA Writing Genre Fiction\r\n\r\nMA Writing Popular Fiction\r\n\r\n<a href=\"https://www.napier.ac.uk/study-with-us/postgraduate\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/EdinburghNapierUniversity/\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://x.com/edinburghnapier?lang=en\" target=\"_blank\" rel=\"noopener\">\r\nX-twitter\r\n</a>\r\n<a href=\"https://www.instagram.com/edinburghnapier/?hl=en\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/@EdinburghNapierUni\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.napier.ac.uk\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.napier.ac.uk/study-with-us/international-students/your-country/americas/usa\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.napier.ac.uk/courses\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.napier.ac.uk/study-with-us/bursaries\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.napier.ac.uk/study-with-us/international-students/your-country/americas/usa/fees-and-scholarships/federal-aid\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.napier.ac.uk/about-us/events\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.napier.ac.uk/research-and-innovation\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.napier.ac.uk/study-with-us/accommodation\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://staff.napier.ac.uk/services/sas/student_development/Careers/Pages/Careers-Support-for-Students.aspx\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.napierstudents.com/organisation/societies/\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"https://www.napier.ac.uk/study-with-us/international-students/how-to-apply\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"Edinburgh Napier University","post_link":"https://theukstudyexpert.com/universities/edinburgh-napier-university/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Edinburgh Napier\" width=\"300\" height=\"145\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/Untitled-design-80-e1723220736832-300x145.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"Business Economics, Engineering, Health Medicine, Life Physical Sciences, Scotland, Technology Computer Science","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"Business Economics, Engineering, Health Medicine, Life Physical Sciences, Scotland, Technology Computer Science","city_country":"Edinburgh, Scotland"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":16627,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Southampton Solent University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Southampton Solent University\" width=\"300\" height=\"300\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/southampton-solent-logo-full-color-rgb-900px-w-72ppi-1-1-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/southampton-solent-university/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Southampton Solent University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Southampton Solent University is all about creating opportunities: for its students, for its staff, for its partners. It offers expertise and experiences you couldn\u2019t get anywhere else.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Southampton Solent University is all about creating opportunities: for its students, for its staff, for its partners. It offers expertise and experiences you couldn\u2019t get anywhere else.","address":"Above Bar St, Southampton SO14 7DW, UK","location":{"lat":"50.9094493","state":"England","country":"United Kingdom","lng":"-1.4029522","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/southampton-solent-university/","zoom":5,"extra_fields":{"post_excerpt":"Southampton Solent University is all about creating opportunities: for its students, for its staff, for its partners. It offers expertise and experiences you couldn\u2019t get anywhere else.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/Court-room-1.jpg\" alt=\"Southampton Solent University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/City-centre-campus-around-parks_1500x1500.jpg\" alt=\"Southampton Solent University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/Spark-for-Meritza-6.jpg\" alt=\"Southampton Solent University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/2019JunJulyAugCaseStudiesMultipleImages_1156w_518h-a.jpg\" alt=\"Southampton Solent University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/East-Park-cafe_1500x1500-007.jpg\" alt=\"Southampton Solent University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/Spark-for-Meritza-3.jpg\" alt=\"Southampton Solent University\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact Southampton Solent University\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> East Park Terrace, Southampton SO14 0YN</p><p><strong>Website:</strong> <a href=\"http://solent.ac.uk\" target=\"_blank\" rel=\"noopener\">http://solent.ac.uk</a></p><p>Southampton Solent University is all about creating opportunities: for its students, for its staff, for its partners. It offers expertise and experiences you couldn\u2019t get anywhere else, opening doors and making introductions. We\u2019re focused on the practical side of higher education \u2013 giving our students the connections, experience, and confidence to turn their newfound knowledge into a career with real, meaningful impact. Whoever you are, whatever your goals, we want to help you make your mark.</p>\n<p></p>\n<p>If there's one thing our 160-year history has taught us, it's that employers are expecting more than ever from modern graduates. Our job is to ensure you leave your course ready to exceed those expectations - equipping you with the hands-on skills and workplace confidence you'll need to succeed.<br><br></p>\n<p></p>\n<p>Employability sits at the heart of everything we do. Our curriculums, created in collaboration with industry employers, guarantee that the skills and knowledge you gain have genuine market value. Our teaching teams extend this value, injecting their first-hand experience into every aspect of your degree. Everyone learns differently. If at any point during your studies you feel you may benefit from extra support, you'll be able to access it. <br><br></p>\n<p></p>\n<p>This isn't limited to academic support either. Whether you want help setting up your own business, are worried about your finances or simply want help with looking for part-time work, our support services will be there for you. International students make up around 15 per cent of the student community here at Solent. We welcome international students from all over the world - giving our city-centre campus and our classrooms a diverse, multicultural feel. <br><br></p>\n<p></p>\n<p><strong>Population: </strong>10,510</p>\n<p><strong>Campus Type: </strong>Urban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li>Teaching Excellence Framework (TEF), Triple Gold Ratings</li><li>15th in the sector for graduate start-ups (HESA 2023)</li></ul><ul data-rte-list=\"default\"><li>37th for Teaching Quality in the Times Good University Guide 2023</li></ul><ul data-rte-list=\"default\"><li>100m investment in our campus and state-of-the-art facilities</li></ul><ul data-rte-list=\"default\"><li>Delivering the Government\u2019s Help to Grow Covid-recovery business management programme</li></ul><ul data-rte-list=\"default\"><li>Awarded the Silver Engage Watermark in recognition of our outstanding commitment to supporting public engagement</li></ul><ul data-rte-list=\"default\"><li>Awarded \u00a34.3m by the Office for Students to create, expand and modernise courses and facilities in healthcare and STEM subject areas.</li></ul>\t\t\n\t\t<h3>Videos</h3>https://www.youtube.com/watch?v=CW2zVJebmTohttps://www.youtube.com/watch?v=Kn2qZCN5GS0https://www.youtube.com/watch?v=3C-Qas6Qekwhttps://www.youtube.com/watch?v=3ozN9Ke1y5k&#038;t=34shttps://www.youtube.com/watch?v=HwgBERD2VQs\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p><strong>Foundation Entry</strong></p><p>\u00a0</p><ul><li>High School Graduation Diploma \u2013 minimum 2.75 GPA</li></ul><p>\u00a0</p><p><strong>Undergraduate Entry</strong></p><p>\u00a0</p><ul><li>High School Graduation Diploma \u2013 minimum 2.8 GPA</li></ul><p>\u00a0</p><p>With (one or more of the following)</p><p>\u00a0</p><ul><li>SAT scores (1100 in Maths, Critical Thinking &amp; Writing or 370 in a relevant subject; current system)</li><li>ACT scores (24 overall in 2 or more subjects)</li><li>AP scores (minimum grade 3 in 2 relevant subjects)</li></ul>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<p>BA (Hons) Interior Design<br />BA (Hons) Architectural Design and Technology<br />BSc (Hons) Quantity Surveying<br />BSc (Hons) Construction Management<br />BSc (Hons) Construction Management (Part-Time)<br />BSc (Hons) International Construction, Design Sustainability (top-up)<br />HNC Architectural Technology<br />HNC Civil Engineering<br />HNC Construction Management<br />HNC Quantity Surveying<br />BA (Hons) Fine Art<br />BA (Hons) Graphic Design<br />BA (Hons) Illustration<br />BA (Hons) Interior Design Decoration<br />BA (Hons) Photography<br />BA (Hons) Prosthetics and Special Effects Design<br />BSc (Hons) Accountancy and Finance<br />BSc (Hons) Business Management <br />BSc (Hons) Business Management with Digital Technologies<br />BSc (Hons) Business Management with Finance<br />BSc (Hons) Business Management with Marketing<br />BSc (Hons) International Business Management<br />BSc (Hons) Computer Network Engineering<br />BSc (Hons) Computer Science<br />BSc (Hons) Cyber Security<br />BSc (Hons) Software Engineering<br />HNC Cyber Security Technologist<br />HNC Data Analyst<br />HNC Network Engineer<br />BA (Hons) Animation<br />BA (Hons) CGI and Visual Effects<br />BA (Hons) Computer Games (Art)<br />BA (Hons) Digital and Game Art Top-Up<br />BSc (Hons) Computer Games Programming and Design<br />BEng (Hons) Electronic Engineering<br />BEng (Hons) Mechanical Engineering<br />BEng (Hons) Renewable Energy Engineering<br />BEng (Hons) Yacht and Powercraft Design<br />BEng (Hons) Yacht Design and Production<br />HNC Engineering<br />BA (Hons) Sports Journalism<br />BA (Hons) Fashion Design<br />BA (Hons) Fashion Management with Marketing<br />BA (Hons) Fashion and Beauty Media<br />BA (Hons) Fashion Photography<br />BA (Hons) Fashion Styling and Creative Direction<br />BA (Hons) Make-Up and Hair Design<br />BA (Hons) Film and Television<br />BA (Hons) Film Production<br />BA (Hons) Media Production<br />BA (Hons) Post Production for Film and Television<br />BA (Hons) Television Production<br />BSc (Hons) Live Event Technology<br />BSc (Hons) Adult Nursing Practice<br />BSc (Hons) Biomedical Science<br />FdSc Health and Social Care (Health Care Assistant Practitioner<br />FdSc Health and Social Care (Nursing Associate)<br />FdSc Health Care Play Specialism<br />LLB (Hons) Law<br />BSc (Hons) Maritime Business<br />BSc (Hons) Maritime Management Top-Up<br />BSc (Hons) Maritime Sciences<br />BSc (Hons) Shipping and Port Management<br />FdEng Marine Engineering<br />FdSc Nautical Science<br />HND Marine Electrical and Electronic Engineering<br />HND Nautical Science<br />BEng (Hons) Marine Electrical and Electronic Engineering<br />BEng (Hons) Marine Engineering<br />BSc (Hons) Nautical Science<br />BA (Hons) Acting and Performance<br />BA (Hons) Digital Music<br />BA (Hons) Music Business<br />BA (Hons) Musical Theatre<br />BA (Hons) Popular Music Performance and Production<br />BMus (hons) Popular Music Performance<br />BSc (Hons) Popular Music Production<br />BSc (Hons) Mental Health Nursing<br />BSc (Hons) Psychology<br />BSc (Hons) Psychology with Counselling and Mental Health<br />BSc (Hons) Psychology and Sociology<br />BSc (Hons) Sport and Exercise Psychology<br />BA (Hons) Criminology<br />BA (Hons) Criminology and Sociology<br />BA (Hons) Social Work<br />BA (Hons) Sociology<br />BSc (Hons) Criminal Investigation with Psychology<br />BSc (Hons) Criminology and Psychology<br />BA (Hons) Physical Education<br />BA (Hons) Sport Coaching and Physical Education (Top-Up)<br />BSc (Hons) Sport and Exercise Therapy<br />BSc (Hons) Football Studies<br />BSc (Hons) Health, Nutrition and Exercise Science<br />BSc (Hons) Sport and Exercise Science<br />BSc (Hons) Sport Coaching<br />BSc (Hons) Sport Management <br />BA (Hons) Education <br />LLB (Hons) Law with Business<br />LLB (Hons) Law with Criminology</p>\n\t\t\t<a href=\"https://www.solent.ac.uk/courses\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>Postgraduate degree US entry requirements Honours degree at 2:2 or higher in any discipline, or extensive industrial experience in subject area.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<p>MSc Sustainable Construction Management<br />MSc Sustainable Refurbishment<br />MSc Sustainable Building Design<br />MA Fine Art (Coming Soon)<br />MA Visual Communication<br />MA Internal Communication Management (ran by IoIC)<br />MBA Global Master of Business Administration<br />MSc Project Management<br />MSc Digital Marketing<br />MSc Financial Management<br />MSc Logistics Management<br />MSc Strategic Management<br />MSc Applied AI and Data Science<br />MSc Computer Engineering<br />MSc Cyber Security Engineering<br />MSc Digital Design<br />MSc Sustainable Marine Craft and Superyacht Design (Coming Soon)<br />MA Sports Broadcast Journalism<br />MA Creative Direction for Fashion and Beauty<br />MA Digital Fashion<br />MA Make-up and Hair Design Futures<br />MA Film Production<br />MA Post Production in Film and Television<br />Independent and Supplementary Prescribing<br />MSc General Practice (Nursing and Allied Health Professionals)<br />PGCert Independent Prescribing Practice<br />LLM Commercial Law and Professional Legal Practice<br />LLM Intellectual Property Law and Professional Legal Practice<br />MSc International Maritime Business<br />MSc International Shipping and Logistics<br />MSc Shipping Operations<br />MA Social Work<br />PGDip Social Work (Coming Soon)<br />MA Physical Education and School Sport<br />MA Sport Management<br />MSc Clinical Exercise Science<br />MSc Football Science<br />MSc Sport and Exercise Medicine in Football<br />MSc Sport Science for Performance Coaching<br />MSc Strength and Conditioning</p>\n\t\t\t<a href=\"https://www.solent.ac.uk/courses\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"http://facebook.com/solentuniversity\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://twitter.com/solentuni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://instagram.com/solentuniversity\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.youtube.com/@SolentUni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"http://solent.ac.uk\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/international/country-specific-information/united-states\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/finance/tuition-fees\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/finance/scholarships\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/events\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/research-innovation-enterprise/research-at-solent\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/accommodation/find-a-home\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/studying-at-solent/student-support/career-employability-advice\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solentsu.co.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"https://www.solent.ac.uk/how-to-apply\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"Southampton Solent University","post_link":"https://theukstudyexpert.com/universities/southampton-solent-university/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Southampton Solent University\" width=\"300\" height=\"300\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/southampton-solent-logo-full-color-rgb-900px-w-72ppi-1-1-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, England, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"2","taxonomy=category":"Universities","taxonomy=post_tag":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, England, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"Southampton, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":13844,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"King&#8217;s College London","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"King&#039;s College London\" width=\"300\" height=\"240\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Kings-College-London-e1725894283670-300x240.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/kings-college-london/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">King&#8217;s College London</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                King's is a globally recognised university and is currently ranked 3rd in London, 7th in the UK, and 31st in the world (QS World University Rankings 2021). King\u2019s has over 36,000 students from 185 different countries around the globe.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"King's is a globally recognised university and is currently ranked 3rd in London, 7th in the UK, and 31st in the world (QS World University Rankings 2021). King\u2019s has over 36,000 students from 185 different countries around the globe.","address":"Stamford St, London SE1 9NH, UK","location":{"lat":"51.5056185","state":"England","country":"United Kingdom","lng":"-0.113562","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/kings-college-london/","zoom":5,"extra_fields":{"post_excerpt":"King's is a globally recognised university and is currently ranked 3rd in London, 7th in the UK, and 31st in the world (QS World University Rankings 2021). King\u2019s has over 36,000 students from 185 different countries around the globe.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Kings.png\" alt=\"King's College London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Kings-1.png\" alt=\"King's College London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Kings-2.png\" alt=\"King's College London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Kings-3.png\" alt=\"King's College London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Kings-4.png\" alt=\"King's College London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Kings-5.png\" alt=\"King's College London\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact King\u2019s College London\r\n</a>\r\n\r\n<strong>Location:</strong> JCMB, 57 Waterloo Road, London, SE1 8WA United Kingdom\r\n\r\n<strong>Website:</strong> <a href=\"https://www.kcl.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://kcl.ac.uk/</a>\r\n<h3>Overview</h3>\r\nThe 4th oldest university in England, King's is ranked in the top 10 UK universities in the world with 5 campuses based in the heart of London. King\u2019s has over 36,000 students from 185 different countries around the globe, representing a diverse and multicultural community much like the city of London itself.\r\n\r\nKing's is part of the elite Russell Group, which means research is at the heart of our undergraduate and postgraduate student experiences. And with the oldest and one of the most active students' unions in the UK, community is also a core value to the King's campus. Our 2029 strategic vision focuses on civic engagement, truly making King's an impactful institution in the great city of London.\r\n\r\n<strong>Population: </strong>36,000\r\n\r\n<strong>Campus Type: </strong>Urban\r\n<h3>Quick Facts</h3>\r\n<ul data-rte-list=\"default\">\r\n \t<li>Founded in 1829 by King George IV and the Duke of Wellington.</li>\r\n \t<li>5 campuses situated across central London.</li>\r\n \t<li>9 academic faculties with over 175 programmes.</li>\r\n \t<li>Ranked #35 in the QS World University Rankings 2022.</li>\r\n \t<li>King's College London Students' Union (KCLSU) is the oldest students' union in the UK, founded in 1873 as the Union Society of King's College London.</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://youtu.be/7pmQ7xWkGcshttps://youtu.be/1trvO6dqQUIhttps://youtu.be/gOCDnIuM664https://youtu.be/TaQQLdDE3Pkhttps://youtu.be/sjivp96REo8https://www.youtube.com/watch?v=kMHQWFBZL_A\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nApplicants with US high school qualifications can meet our entry requirements through a combination of APs, Honors/Dual Enrolment Class, SATs and ACTs* listed below.\r\n\r\n*Please note we will only consider Honors/Dual Enrolment Class, for US-domiciled applicants only, if the school does not teach enough AP subjects. Honors Classes must be taken for one year at grade 12 level, and Dual Enrolment (College) Classes must be taken for one semester of at least 3 credits. We do not allow Honors Classes to meet subject requirements but we consider Dual Enrolment (College) Classes on a case-by-case basis. We no longer consider SAT subject tests. We cannot consider ACT Super Scores.\r\n\r\nHigh School Diploma plus one of the following:\r\n<ul data-rte-list=\"default\">\r\n \t<li>5 AP\u2019s*</li>\r\n \t<li>3 AP\u2019s and the SAT (minimum 1230)</li>\r\n \t<li>3 AP\u2019s* and the ACT (minimum 23)</li>\r\n</ul>\r\nPlease see further information by specific subject <a href=\"https://www.kcl.ac.uk/study/undergraduate/how-to-apply/entry-requirements#section-10\">here</a>.\r\n\r\nOR\r\n<ul data-rte-list=\"default\">\r\n \t<li>International Baccalaureate Diploma*</li>\r\n \t<li>French Baccalaureate Diploma*</li>\r\n</ul>\r\n*Applicants must study three subjects in-depth, including any subjects stated in their online prospectus as \u2018compulsory\u2019 for your programme.\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n<ul id=\"majors\">\r\n \t<li>Arts &amp; Humanities</li>\r\n \t<li>Business</li>\r\n \t<li>Dentistry, Oral &amp; Craniofacial Sciences</li>\r\n \t<li>Law</li>\r\n</ul>\r\n<ul id=\"majors\">\r\n \t<li>Life Sciences &amp; Medicine</li>\r\n \t<li>Natural, Mathematical &amp; Engineering Sciences</li>\r\n \t<li>Nursing, Midwifery &amp; Palliative Care</li>\r\n \t<li>Psychiatry, Psychology &amp; Neuroscience</li>\r\n \t<li>Social Science &amp; Public Policy</li>\r\n</ul>\r\n<a href=\"https://www.kcl.ac.uk/study/undergraduate/apply\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nMinimum GPA 3.0 - 3.7 depending on the programme.\r\n\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n<ul id=\"majors\">\r\n \t<li>Arts &amp; Humanities</li>\r\n \t<li>Business</li>\r\n \t<li>Dentistry, Oral &amp; Craniofacial Sciences</li>\r\n \t<li>Law</li>\r\n</ul>\r\n<ul id=\"majors\">\r\n \t<li>Life Sciences &amp; Medicine</li>\r\n \t<li>Natural, Mathematical &amp; Engineering Sciences</li>\r\n \t<li>Nursing, Midwifery &amp; Palliative Care</li>\r\n \t<li>Psychiatry, Psychology &amp; Neuroscience</li>\r\n \t<li>Social Science &amp; Public Policy</li>\r\n</ul>\r\n<a href=\"https://www.kcl.ac.uk/study/postgraduate/apply\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/kingscollegelondon\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://twitter.com/KingsCollegeLon\" target=\"_blank\" rel=\"noopener\">\r\nTwitter\r\n</a>\r\n<a href=\"https://www.instagram.com/LifeAtKings/\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/user/kingscollegelondon\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.kcl.ac.uk/\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.kcl.ac.uk/study/international/offices/north-america/usa\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.kcl.ac.uk/study/international/fees-and-funding\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.kcl.ac.uk/study/scholarships/index\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://apply.kcl.ac.uk/\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.kcl.ac.uk/events\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://kclpure.kcl.ac.uk/portal/\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.kcl.ac.uk/accommodation\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.kcl.ac.uk/careers\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.kclsu.org/\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"https://google.com/\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"King&#8217;s College London","post_link":"https://theukstudyexpert.com/universities/kings-college-london/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"King&#039;s College London\" width=\"300\" height=\"240\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Kings-College-London-e1725894283670-300x240.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"1","taxonomy=category":"Universities","taxonomy=post_tag":"3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"London, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10243,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Imperial College London","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Imperial College London\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Untitled-design-21-e1712874673508-300x158.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/imperial-college-london/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Imperial College London</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Imperial is one of the world\u2019s 10 top universities (QS World Rankings 2022), in one of its most iconic cities \u2013 London, UK. Today we have one of the highest concentrations of high-impact research of any major UK university.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Imperial is one of the world\u2019s 10 top universities (QS World Rankings 2022), in one of its most iconic cities \u2013 London, UK. Today we have one of the highest concentrations of high-impact research of any major UK university.","address":"Exhibition Rd, South Kensington, London SW7 2BX, UK","location":{"lat":"51.49882220000001","state":"England","country":"United Kingdom","lng":"-0.1748735","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/imperial-college-london/","zoom":5,"extra_fields":{"post_excerpt":"Imperial is one of the world\u2019s 10 top universities (QS World Rankings 2022), in one of its most iconic cities \u2013 London, UK. Today we have one of the highest concentrations of high-impact research of any major UK university.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Imperial.png\" alt=\"Imperial College London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Imperial-1.png\" alt=\"Imperial College London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Imperial-2.png\" alt=\"Imperial College London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Imperial-3.png\" alt=\"Imperial College London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Imperial-4.png\" alt=\"Imperial College London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Imperial-5.png\" alt=\"Imperial College London\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact Imperial College London\r\n</a>\r\n\r\n<strong>Location:</strong> South Kensington Campus, Exhibition Road, London, SW7 2AZ, UK\r\n\r\n<strong>Website:</strong> <a href=\"https://www.imperial.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://imperial.ac.uk/</a>\r\n<h3>Overview</h3>\r\nImperial College London a world\u2013leading university for science, technology, engineering, medicine and business, in one of its most iconic cities \u2013 London, UK.\r\n\r\n&nbsp;\r\n\r\nWe were founded in 1907 with a mission \u2018To be useful\u2019 \u2013 but we know that before anyone can usefully change something, they first need to understand it.\u00a0 That\u2019s what we do: We use science to try to understand more of the universe, and improve the lives of more people in it.\r\n\r\n&nbsp;\r\n\r\nToday, Imperial has one of the highest concentrations of high-impact research of any major UK university. The research and innovations we produce are right now helping to navigate some of the world\u2019s toughest challenges in global health, climate change, AI, business leadership and more. We are a truly global community, bringing together the best people from around the world to the heart of one world\u2019s most exciting cities. With students from over 140 countries, and a specialist community and a research-led curriculum our degrees open doors and our discoveries change lives.\r\n\r\n&nbsp;\r\n\r\n<strong>Population: </strong>20,000\r\n\r\n<strong>Campus Type: </strong>Urban\r\n<h3>Quick Facts</h3>\r\n<ul data-rte-list=\"default\">\r\n \t<li>Imperial College is the only UK university to focus entirely on science, engineering, medicine and business.</li>\r\n \t<li>Ranked 7th in the world (QS World Rankings) 5th Most International University in the world (Times Higher Education).</li>\r\n \t<li>Over 50% of Imperial College students come from outside the UK, from over 130 different countries</li>\r\n \t<li>380 clubs and societies - From baking to biking, and from hip hop to Harry Potter \u2013 whatever inspires you, you\u2019ll find like-minded people to share it with at Imperial College.</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://www.youtube.com/watch?v=QUBsf-2GX5shttps://youtu.be/FyoM7fhJ1_4https://www.youtube.com/watch?v=2_hGbm-cXlMhttps://youtu.be/RgnviWci1Z0\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nImperial College requires a minimum of 3-4 AP tests with Grades of 5 (with specific subjects). Expected to be taken alongside a relevant high school diploma.\r\n\r\n<strong>\u00a0</strong>\r\n\r\n<strong>Deadlines</strong>\r\n\r\nMedicine - October 15\r\n\r\nOther - Equal Consideration Deadline (Mid-January - changes every year)\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n<ul id=\"majors\">\r\n \t<li><strong>Fall Intake</strong></li>\r\n \t<li>Addiction and Mental Health MSc</li>\r\n \t<li>Architectural History, Research and Writing MA</li>\r\n \t<li>Architecture \u2013 RIBA 2</li>\r\n \t<li>Architecture Apprenticeship (RIBA 2 and 3) \u2013 MArch</li>\r\n \t<li>Child and Adolescent Mental Health MSc</li>\r\n \t<li>Conference Interpreting \u2013 MA</li>\r\n \t<li>Corporate Social Responsibility and Sustainability \u2013 Adv Dip Pro Dev</li>\r\n \t<li>Cryptography MSc</li>\r\n \t<li>Culture, Heritage and Leisure Management \u2013 MSc/PG Dip/PG Cert</li>\r\n \t<li>Design for Cultural Commons \u2013 PG Cert</li>\r\n \t<li>Design for Cultural Commons \u2013 PG Dip</li>\r\n \t<li>Dietetics and Nutrition \u2013 MSc</li>\r\n \t<li>Documentary Film Production \u2013 MA</li>\r\n \t<li>Employment Law and Practice \u2013 Advance Diploma Prof Dev</li>\r\n \t<li>Environmental, Sustainable and Regeneration Design MA</li>\r\n \t<li>Fine Arts \u2013 MFA</li>\r\n \t<li>Furniture Design \u2013 MA</li>\r\n \t<li>Human Resource Management \u2013 PG Dip</li>\r\n \t<li>Interior Design \u2013 MA</li>\r\n \t<li>International Accounting and Finance MSc</li>\r\n \t<li>Interpreting \u2013 MA</li>\r\n \t<li>Jewellery and Silversmithing \u2013 MA</li>\r\n \t<li>Law: Common Professional Exam \u2013 GDL</li>\r\n \t<li>Legal Practice Course \u2013 PG Dip</li>\r\n \t<li>LLM Legal Practice</li>\r\n \t<li>LLM Legal Practice (Top-up) \u2013 LLM</li>\r\n \t<li>Master of Philosophy (MPhil)</li>\r\n \t<li>PGCE Early Years (3 \u2013 7) \u2013 PGCE</li>\r\n \t<li>PGCE Primary 5-11 \u2013 PGCE</li>\r\n \t<li>PGCE Secondary English with Drama \u2013 PGCE</li>\r\n \t<li>PGCE Secondary English with Media \u2013 PGCE</li>\r\n \t<li>PGCE Secondary Mathematics \u2013 PGCE</li>\r\n \t<li>PGCE Secondary Modern Languages \u2013 PGCE</li>\r\n \t<li>PGCE Secondary Science with Biology \u2013 PGCE</li>\r\n \t<li>PGCE Secondary Science with Chemistry \u2013 PGCE</li>\r\n \t<li>PGCE Secondary Science with Physics \u2013 PGCE</li>\r\n \t<li>Primary (7-11) (Key Stage 2) \u2013 PGCE</li>\r\n \t<li>Product Design \u2013 MA</li>\r\n \t<li>Public Art and Performance \u2013 MA</li>\r\n \t<li>Robotics with Artificial Intelligence \u2013 MSc</li>\r\n \t<li>Social Work \u2013 MSc</li>\r\n \t<li>Specialised Translation PG Cert</li>\r\n \t<li>Sports Therapy \u2013 MSc</li>\r\n \t<li>Textile Design \u2013 MA</li>\r\n \t<li>Translation \u2013 MA</li>\r\n \t<li>Translation Technology PG Cert</li>\r\n \t<li>Visual Communication: Graphic Design</li>\r\n \t<li>Visual Communication: Illustration</li>\r\n</ul>\r\n<ul id=\"majors\">\r\n \t<li><strong>January Intake</strong></li>\r\n \t<li>Architecture: Professional Practice in Architecture \u2013 RIBA 3</li>\r\n \t<li>Artificial Inteligence MA</li>\r\n \t<li>Assessment only (AO) route to Qualified Teacher Status \u2013 QTS</li>\r\n \t<li>Aviation Management in the Digital Age \u2013 MSc</li>\r\n \t<li>Biomedical Science \u2013 MSc</li>\r\n \t<li>Biomedical Studies Distance Learning \u2013 MSc</li>\r\n \t<li>Blood Science \u2013 MSc</li>\r\n \t<li>Blood Science Distance Learning \u2013 MSc</li>\r\n \t<li>Cancer Immunotherapy \u2013 MSc</li>\r\n \t<li>Cancer Pharmacology \u2013 MSc</li>\r\n \t<li>Computer Networking and Cyber Security \u2013 MSc</li>\r\n \t<li>Computer Networking and Cyber Security with Work Experience \u2013 MSc</li>\r\n \t<li>Corporate Social Responsibility and Sustainability \u2013 MSc</li>\r\n \t<li>Creative Digital and Professional Writing \u2013 MA</li>\r\n \t<li>Criminology \u2013 MSc</li>\r\n \t<li>Data Analytics \u2013 MSc</li>\r\n \t<li>Digital Media \u2013 MA</li>\r\n \t<li>Doctor of Philosophy \u2013 MPhil / PhD</li>\r\n \t<li>Early Childhood Studies \u2013 MA</li>\r\n \t<li>Education \u2013 MA</li>\r\n \t<li>English Language Teaching (Distance Learning) \u2013 MA</li>\r\n \t<li>Financial Services Law, Regulation and Compliance \u2013 LLM/PG Dip/PG Cert</li>\r\n \t<li>Food Science \u2013 MSc</li>\r\n \t<li>Health and Social Care Management and Policy \u2013 MSc</li>\r\n \t<li>Human Nutrition and (Public Health/Sports) \u2013 MSc</li>\r\n \t<li>Human Resource Management \u2013 MA</li>\r\n \t<li>Human Rights and International Conflict \u2013 MA</li>\r\n \t<li>Information Technology Distance Learning \u2013 MSc</li>\r\n \t<li>International Banking and Finance MSc</li>\r\n \t<li>International Business Management MSc</li>\r\n \t<li>International Business Management with Project Management MSc</li>\r\n \t<li>International Events, Leisure and Tourism Management</li>\r\n \t<li>International Relations \u2013 MA</li>\r\n \t<li>International Trade and Finance \u2013 MSc</li>\r\n \t<li>Learning and Teaching in Higher Education \u2013 MA</li>\r\n \t<li>Maritime law (Top-Up) (Distance Learning) -LLM</li>\r\n \t<li>Maritime Law LLM/PG Dip/PG Cert</li>\r\n \t<li>Marketing \u2013 MA</li>\r\n \t<li>Master of Business Administration</li>\r\n \t<li>Media Law LLM/PG Dip/PG Cert</li>\r\n \t<li>Medical Genomics \u2013 MSc</li>\r\n \t<li>Organised Crime and Global Security \u2013 MA</li>\r\n \t<li>Pharmaceutical Science and Drug Delivery Systems \u2013 MSc</li>\r\n \t<li>Public Health \u2013 MSc</li>\r\n \t<li>Teaching Languages (Arabic) \u2013 MA</li>\r\n \t<li>Teaching Languages (English) \u2013 MA</li>\r\n \t<li>Technology Entrepreneurship \u2013 MSc</li>\r\n \t<li>Youth and Community Work (Advanced Practice) \u2013 MSc</li>\r\n \t<li>Youth and Community Work (with JNC Recognition) \u2013 MSc</li>\r\n</ul>\r\n<a href=\"https://www.imperial.ac.uk/study/ug/courses/\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nOur minimum requirement is based on the university's selectivity ranking so minimum grade requirements will range from 3.0 / 4.0 to 3.6 / 4.0 depending on the institution.\r\n\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n<ul id=\"majors\">\r\n \t<li>Advanced Aeronautical Engineering MSc</li>\r\n \t<li>Advanced Chemical Engineering MSc</li>\r\n \t<li>Advanced Chemical Engineering with Biotechnology MSc</li>\r\n \t<li>Advanced Chemical Engineering with Process Systems Engineering MSc</li>\r\n \t<li>Advanced Chemical Engineering with Structured Product Engineering MSc</li>\r\n \t<li>Advanced Computational Methods for Aeronautics, Flow Management and Fluid-Structure Interaction MSc</li>\r\n \t<li>Advanced Computing MSc</li>\r\n \t<li>Advanced Materials for Sustainable Infrastructure MSc</li>\r\n \t<li>Advanced Materials Science and Engineering MSc</li>\r\n \t<li>Advanced Mechanical Engineering MSc</li>\r\n \t<li>Advanced Molecular Synthesis MRes</li>\r\n \t<li>Allergy PG Cert</li>\r\n \t<li>Allergy PG Dip</li>\r\n \t<li>Allergy MSc</li>\r\n \t<li>Analogue and Digital Integrated Circuit Design MSc</li>\r\n \t<li>Applied Biosciences and Biotechnology MSc</li>\r\n \t<li>Applied Computational Science and Engineering MSc</li>\r\n \t<li>Applied Genomics MSc</li>\r\n \t<li>Applied Machine Learning MSc</li>\r\n \t<li>Applied Mathematics MSc</li>\r\n \t<li>Applied Paediatrics MSc</li>\r\n \t<li>Applied Paediatrics PG Cert</li>\r\n \t<li>Applied Paediatrics PG Dip</li>\r\n \t<li>Artificial Intelligence MSc</li>\r\n \t<li>Bioengineering MRes</li>\r\n \t<li>Bioinformatics and Theoretical Systems Biology MSc</li>\r\n \t<li>Biological and Physical Chemistry MRes</li>\r\n \t<li>Biomedical Engineering MSc</li>\r\n \t<li>Biomedical Research MRes</li>\r\n \t<li>Biomedical Research (Anaesthetics, Pain Medicine and Intensive Care) MRes</li>\r\n \t<li>Biomedical Research (Bacterial Pathogenesis and Infection) MRes</li>\r\n \t<li>Biomedical Research (Data Science) MRes</li>\r\n \t<li>Biomedical Research (Epidemiology, Evolution and Control of Infectious Diseases) MRes</li>\r\n \t<li>Biomedical Research (Microbiome in Health and Disease) MRes</li>\r\n \t<li>Biomedical Research (Molecular Basis of Human Disease) MRes</li>\r\n \t<li>Biomedical Research (Respiratory and Cardiovascular Science) MRes</li>\r\n \t<li>Biosystematics MRes</li>\r\n \t<li>Business MRes</li>\r\n \t<li>Business Analytics MSc</li>\r\n \t<li>Business Analytics (Online) MSc</li>\r\n \t<li>Cancer Biology MRes</li>\r\n \t<li>Cancer Informatics MRes</li>\r\n \t<li>Cancer Technology MRes</li>\r\n \t<li>Cardiovascular and Respiratory Healthcare PG Cert</li>\r\n \t<li>Cardiovascular and Respiratory Healthcare PG Dip</li>\r\n \t<li>Cardiovascular and Respiratory Healthcare MSc</li>\r\n \t<li>Catalysis: Chemistry and Engineering MRes</li>\r\n \t<li>Chemical Biology and Bio-Entrepreneurship MRes</li>\r\n \t<li>Climate Change, Management and Finance MSc</li>\r\n \t<li>Clinical Research MRes</li>\r\n \t<li>Clinical Research PG Cert</li>\r\n \t<li>Communications and Signal Processing MSc</li>\r\n \t<li>Composites: the Science, Technology and Engineering Application of Advanced Composites MSc</li>\r\n \t<li>Computational Methods in Ecology and Evolution MRes</li>\r\n \t<li>Computational Methods in Ecology and Evolution MSc</li>\r\n \t<li>Computing MSc</li>\r\n \t<li>Computing (Artificial Intelligence and Machine Learning) MSc</li>\r\n \t<li>Computing (Management and Finance) MSc</li>\r\n \t<li>Computing (Security and Reliability) MSc</li>\r\n \t<li>Computing (Software Engineering) MSc</li>\r\n \t<li>Concrete Structures MSc</li>\r\n \t<li>Control Systems MSc</li>\r\n \t<li>Digital Chemisty MSc</li>\r\n \t<li>Digital Chemisty MSc</li>\r\n \t<li>Digital Health Leadership PG Dip</li>\r\n \t<li>Drug Discovery and Development: Multidisciplinary Science for Next Generation Therapeutics MRes</li>\r\n \t<li>Earthquake Engineering MSc</li>\r\n \t<li>Ecological Applications MSc</li>\r\n \t<li>Ecology, Evolution and Conservation MSc</li>\r\n \t<li>Ecology, Evolution and Conservation Research MRes</li>\r\n \t<li>Economics and Strategy for Business MSc</li>\r\n \t<li>Ecosystem and Environmental Change MRes</li>\r\n \t<li>Engineering Fluid Mechanics for the Offshore, Coastal and Built Environments MSc</li>\r\n \t<li>Engineering for Biomedicine MSc</li>\r\n \t<li>Environmental Data Science and Machine Learning MSc</li>\r\n \t<li>Environmental Engineering MSc</li>\r\n \t<li>Environmental Technology MSc</li>\r\n \t<li>Epidemiology MSc</li>\r\n \t<li>Experimental Neuroscience MRes</li>\r\n \t<li>Finance MSc</li>\r\n \t<li>Finance and Accounting MSc</li>\r\n \t<li>Financial Technology MSc</li>\r\n \t<li>Future Power Networks MSc</li>\r\n \t<li>General Structural Engineering MSc</li>\r\n \t<li>Genes, Drugs and Stem Cells \u2013 Novel Therapies</li>\r\n \t<li>Genomic Medicine PG Cert</li>\r\n \t<li>Genomic Medicine PG Dip</li>\r\n \t<li>Genomic Medicine MSc</li>\r\n \t<li>Geo-Energy with Machine Learning and Data Science MSc</li>\r\n</ul>\r\n<ul id=\"majors\">\r\n \t<li>Global Innovation Design MA/MSc</li>\r\n \t<li>Global Master of Public Health (Online) MPH</li>\r\n \t<li>Global Statistics (Online) MSc</li>\r\n \t<li>Green Chemistry, Energy and the Environment MRes</li>\r\n \t<li>Health Data Analytics and Machine Learning MSc</li>\r\n \t<li>Health Policy PG Cert</li>\r\n \t<li>Health Policy PG Dip</li>\r\n \t<li>Health Policy MSc</li>\r\n \t<li>Healthcare and Design MSc</li>\r\n \t<li>Healthcare and Design PG Dip</li>\r\n \t<li>Human and Biological Robotics MSc</li>\r\n \t<li>Human Molecular Genetics MSc</li>\r\n \t<li>Hydrology and Water Resources Management MSc</li>\r\n \t<li>Immunology PG Cert</li>\r\n \t<li>Immunology MSc</li>\r\n \t<li>Innovation Design Engineering MA/MSc</li>\r\n \t<li>Innovation, Entrepreneurship and Management MSc</li>\r\n \t<li>International Health Management MSc</li>\r\n \t<li>International Management MSc</li>\r\n \t<li>Investment and Wealth Management MSc</li>\r\n \t<li>Machine Learning and Big Data in the Physical Sciences MRes</li>\r\n \t<li>Machine Learning and Data Science (Online) MSc</li>\r\n \t<li>Management MSc</li>\r\n \t<li>Mathematics and Finance MSc</li>\r\n \t<li>MBA MBA</li>\r\n \t<li>MBA (Executive) MBA</li>\r\n \t<li>MBA (Global Online) MBA</li>\r\n \t<li>MBA (Weekend) MBA</li>\r\n \t<li>Medical Device Design and Entrepreneurship MRes</li>\r\n \t<li>Medical Robotics and Image-Guided Intervention MRes</li>\r\n \t<li>Medical Ultrasound (Echocardopgraphy and Vascular) MSc</li>\r\n \t<li>Metals and Energy Finance MSc</li>\r\n \t<li>Molecular and Cellular Biosciences MRes</li>\r\n \t<li>Molecular Biology and Pathology of Viruses MSc</li>\r\n \t<li>Molecular Engineering MRes</li>\r\n \t<li>Molecular Medicine MSc</li>\r\n \t<li>Molecular Plant and Microbial Sciences MRes</li>\r\n \t<li>Nanomaterials MRes</li>\r\n \t<li>Neurotechnology MRes</li>\r\n \t<li>Optics and Photonics MSc</li>\r\n \t<li>Applied Paediatrics PG Cert</li>\r\n \t<li>Applied Paediatrics PG Dip</li>\r\n \t<li>Applied Paediatrics MSc</li>\r\n \t<li>Patient Safety PG Cert</li>\r\n \t<li>Patient Safety PG Dip</li>\r\n \t<li>Patient Safety MSc</li>\r\n \t<li>Photonics MRes</li>\r\n \t<li>Physics MSc</li>\r\n \t<li>Physics with Extended Research MSc</li>\r\n \t<li>Physics with Nanophotonics MSc</li>\r\n \t<li>Physics with Quantum Dynamics MSc</li>\r\n \t<li>Public Health MPH</li>\r\n \t<li>Pure Mathematics MSc</li>\r\n \t<li>Quantum Fields and Fundamental Forces MSc</li>\r\n \t<li>Reproductive and Developmental Biology PG Cert</li>\r\n \t<li>Reproductive and Developmental Biology MSc</li>\r\n \t<li>Risk Management and Financial Engineering MSc</li>\r\n \t<li>Science Communication MSc</li>\r\n \t<li>Science Media Production MSc</li>\r\n \t<li>Security and Resilience: Science and Technology PG Cert</li>\r\n \t<li>Security and Resilience: Science and Technology PG Dip</li>\r\n \t<li>Security and Resilience: Science and Technology MSc</li>\r\n \t<li>Soft Electronic Materials MRes</li>\r\n \t<li>Soil Mechanics MSc</li>\r\n \t<li>Soil Mechanics and Engineering Geology MSc</li>\r\n \t<li>Soil Mechanics and Engineering Seismology MSc</li>\r\n \t<li>Soil Mechanics and Environmental Geotechnics MSc</li>\r\n \t<li>Statistics MSc</li>\r\n \t<li>Statistics (Applied Statistics) MSc</li>\r\n \t<li>Statistics (Biostatistics) MSc</li>\r\n \t<li>Statistics (Data Science) MSc</li>\r\n \t<li>Statistics (Statistical Finance) MSc</li>\r\n \t<li>Statistics (Theory and Methods) MSc</li>\r\n \t<li>Strategic Marketing MSc</li>\r\n \t<li>Strategic Marketing (Online) MSc</li>\r\n \t<li>Structural Molecular Biology MRes</li>\r\n \t<li>Structural Steel Design MSc</li>\r\n \t<li>Surgical Education PG Dip</li>\r\n \t<li>Surgical Education MEd</li>\r\n \t<li>Surgical Innovation PG Cert</li>\r\n \t<li>Surgical Innovation PG Dip</li>\r\n \t<li>Surgical Innovation MSc</li>\r\n \t<li>Sustainable Energy Futures MSc</li>\r\n \t<li>Systems and Synthetic Biology MRes</li>\r\n \t<li>Taxonomy, Biodiversity and Evolution MSc</li>\r\n \t<li>Translational Neuroscience MSc</li>\r\n \t<li>Transport MSc</li>\r\n \t<li>Tropical Forest Ecology MRes</li>\r\n</ul>\r\n<a href=\"https://www.imperial.ac.uk/study/pg/courses/\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/imperialcollegelondon\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://twitter.com/imperialcollege\" target=\"_blank\" rel=\"noopener\">\r\nTwitter\r\n</a>\r\n<a href=\"https://instagram.com/imperialcollege\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/user/imperialcollegevideo\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.imperial.ac.uk/\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/study/international-students/information-by-region/north-america/\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/study/fees-and-funding/undergraduate/bursaries-grants-scholarships/\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/study/fees-and-funding/undergraduate/bursaries-grants-scholarships/\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/study/ug/fees-and-funding/loans-and-grants/us-loans/\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.imperial.ac.uk/study/visit/events/\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/research-and-innovation/\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/students/accommodation/\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/careers\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.imperialcollegeunion.org/activities/a-to-z\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"https://google.https//www.imperial.ac.uk/study/pg/apply/\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"Imperial College London","post_link":"https://theukstudyexpert.com/universities/imperial-college-london/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Imperial College London\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Untitled-design-21-e1712874673508-300x158.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"3.0, 3.1, 3.2, 3.3+, Business Economics, Engineering, England, Health Medicine, Life Physical Sciences, Technology Computer Science","%_custom_priority_meta_key%":"3","taxonomy=category":"Universities","taxonomy=post_tag":"3.0, 3.1, 3.2, 3.3+, Business Economics, Engineering, England, Health Medicine, Life Physical Sciences, Technology Computer Science","city_country":"London, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10239,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"London Metropolitan University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"London Metropolitan University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/London-Metropolitan-University-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/londonmet/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">London Metropolitan University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Based in England\u2019s historic capital city, London Metropolitan University has a rich history of education with its roots dating back to 1848 offering a wide range of courses across two London campuses. \r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Based in England\u2019s historic capital city, London Metropolitan University has a rich history of education with its roots dating back to 1848 offering a wide range of courses across two London campuses. ","address":"166-220 Holloway Rd, London N7 8DB, UK","location":{"lat":"51.5526146","state":"England","country":"United Kingdom","lng":"-0.1113049","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/londonmet/","zoom":5,"extra_fields":{"post_excerpt":"Based in England\u2019s historic capital city, London Metropolitan University has a rich history of education with its roots dating back to 1848 offering a wide range of courses across two London campuses. ","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/1-12.png\" alt=\"London Metropolitan University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/1-13.png\" alt=\"London Metropolitan University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/1-14.png\" alt=\"London Metropolitan University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/1-15.png\" alt=\"London Metropolitan University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/1-16.png\" alt=\"London Metropolitan University\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact London Metropolitan University\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> Tower Building, 166-220 Holloway Road, London, N7 8DB</p><p><strong>Website:</strong> <a href=\"http://www.londonmet.ac.uk/\" target=\"_blank\" rel=\"noopener\">http://londonmet.ac.uk/</a></p><h3>Overview</h3><p>Based in England\u2019s historic capital city, London Metropolitan University has a rich history of education with its roots dating back to 1848. Taking its current form following a merger of two well-renowned universities in 2002, it offers a wide range of courses across two London campuses.</p><p>\u00a0</p><p>The Aldgate campus is home to the University\u2019s architecture, art and design courses, with all other subjects being taught at the Holloway campus (opposite Holloway Road tube station). This campus in north London has developed into a modern, progressive learning centre and over the last 100 years has developed a strong reputation for widening access to education for those around the world.</p><p>\u00a0</p><p>Students studying at London Metropolitan University will receive excellent specialised tuition, offering a wide number of high-quality courses covering various subject areas. This is underpinned by the expertise of experienced academic staff and access to world-class resources. Those studying at the university also have access to all communal spaces including libraries, cafes and eateries. There are also superb links to businesses and the six distinct schools at London Met link into various sectors and harness research opportunities for staff and students alike helping to create an engaging and diverse learning experience.</p><p>\u00a0</p><p>London is an exciting and culturally diverse city with immense opportunities in terms of work, education and social life, making it a popular destination for international students. London Metropolitan University boasts an active and involved population of international students, and offers advice and assistance with accommodation, funding and careers, as well as academic and wellbeing support.</p><p>\u00a0</p><p><strong>Population: </strong>12,000</p><p><strong>Campus Type: </strong>Urban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul><li><strong>Teaching Quality:</strong> Acclaimed for its student support, ranking 9th for teaching quality and 10th for student experience (The Times and Sunday Times Good University Guide 2024), ensuring an enriching and supportive learning environment.</li><li><strong>Prime London Locations:</strong> The Aldgate campus is just a 15-minute stroll from the iconic Tower Bridge, while the Holloway campus is conveniently located just two stops from the International (and magical) travel hub of Kings Cross Station, placing the best of London at your doorstep.</li><li><strong>Cutting-edge Facilities:</strong> Boasts an array of state-of-the-art facilities across various disciplines, including one of the most advanced science teaching facilities in Europe; a \u00a330 million Science Centre, an innovative health simulation suite, mock courtroom, interpreting suite, TV studio, along with dedicated workshops and studio spaces for art, architecture, and design.</li><li><strong>Championing Sustainability:</strong> Widely recognised for their significant contributions to environmental sustainability, London Met leads UK universities with an 80% reduction in carbon emissions since 2005-06 (People and Planet Sustainability League Table, 2021).</li><li><strong>Career-focused Programs:</strong> With a 100% commitment to student success, all undergraduate programs at London Met feature work-related learning opportunities such as placements, client projects, and on-campus experiences, supported by the Accelerator business incubator and pro bono, charities and small business clinics, ensuring graduates are career-ready. London Met ranks 6th in the UK for producing CEOs and Managing Directors (Hitachi Capital Invoice Finance, 2021).</li><li><strong>Commitment to Equity and Inclusion:</strong> The university's dedication to diversity and inclusion is underscored by the establishment of the Centre for Equity and Inclusion in 2020, with a \u00a315 million commitment towards advancing racial equity and inclusion.</li><li style=\"list-style-type: none;\">\u00a0</li></ul>\t\t\n\t\t<h3>Videos</h3>https://www.youtube.com/watch?v=2QuKXflWChs&#038;ab_channel=LondonMetropolitanUniversityhttps://www.youtube.com/watch?v=2UAH1pLxtc0&#038;list=PLItN3B6F2de_DFyHkT460cg6vI49DMC9_&#038;index=3&#038;ab_channel=LondonMetropolitanUniversityhttps://youtu.be/miEODksicmohttps://www.youtube.com/watch?v=INT_BkJt0ekhttps://youtu.be/97Y5rc0abs4https://www.youtube.com/watch?v=d_2Xr07DGnA\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><h5><strong>3 Year Undergraduate Degrees</strong></h5><p><strong>EITHER</strong></p><p>One of the following qualifications:</p><ul><li>SAT: 1100+ (550+ in both)</li><li>ACT: 22+</li><li>2 Advanced Placement (AP) exam with score of 3+</li><li>At least one year (30 credits) at a US community college or university, cumulative GPA 2.7+</li></ul><ul><li>Accepted combinations of exams are:<ul><li>1 AP (3+) and 1 SAT (550+)</li><li>1 AP (3+) and 2 HL IB modules (H5+)</li><li>1 SAT (550+) and 2 HL IB modules (H5+)</li></ul></li><li>For courses that carry UCAS tariff points (e.g. IB) please see the course page for specific UCAS point requirement</li></ul><p><strong>OR</strong></p><p><br />One of the following award qualifications with a\u00a0<a href=\"https://www.londonmet.ac.uk/usa-assessment-alternative/\">USA Assessment Alternative</a>\u00a0(students who have taken SAT/ACT/APs within the past 2 years are ineligible for USA alternative assessment)</p><ul><li>US High School Diploma cumulative GPA 2.8+</li></ul><ul><li>GED 165+ in each of 4 subject tests\u00a0</li></ul><p>\u00a0</p><h5><strong>4 Year Undergraduate Degrees (Includes a Foundation Year)</strong></h5><p><strong> EITHER<br /></strong>One of the following award qualifications:</p><ul><li>SAT: 900+ (450+ in both)</li><li>ACT: 16+</li><li>2 Advanced Placement (AP) exam score of 2+</li></ul><p>For courses that carry UCAS tariff points (e.g. IB) please see the course page for specific UCAS point requirements.</p><p>\u00a0</p><p><strong>OR</strong></p><p>\u00a0</p><p>One of the following award qualifications with a <a href=\"https://www.londonmet.ac.uk/usa-assessment-alternative/\">USA Assessment Alternative</a> (students who have taken SAT/ACT/AP's within the past 2 years are ineligible for USA alternative assessment)</p><ul><li>US High School Diploma cumulative GPA 2.0+</li><li>GED 145+ in each of 4 subject tests<strong><br /></strong><strong>\u00a0</strong></li></ul><p><strong>Transfer Applicants:\u00a0</strong></p><p>Students who have completed an associate\u2019s degree at a community college or two years (60 credits) at a US university with a GPA of 2.7 in a relevant subject area may be considered for Advanced Entry to Year 2 (evaluated on a case-by-case basis). Find out more about<a href=\"https://www.londonmet.ac.uk/international/applying/countries/students-from-usa/transfer-students/\"> transferring from the USA</a>.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<p>\u00a0</p><ul><li>Accounting and Finance (including foundation year) BA (Hons)</li><li>Accounting and Finance BA\u00a0</li><li>Accounting and Financial Services (Top-up) BA (Hons)</li><li>Advertising, Marketing Communications and Public Relations BA\u00a0</li><li>Airline, Airport and Aviation Management (including foundation year) BSc (Hons)</li><li>Airline, Airport and Aviation Management BSc (Hons)</li><li>Architect Apprenticeship (Level 7) (RI Part 2 and Part 3) BA\u00a0</li><li>Architecture (including foundation year) BA (Hons)</li><li>Architecture (Top-Up) BA (Hons)</li><li>Architecture Apprenticeship (RI 2 and 3) &#8211; MArch (RI 2), PG Cert (RI 3) BA\u00a0</li><li>Architecture BA\u00a0</li><li>Art and Design (including foundation year) BA (Hons)</li><li>Banking and Finance (including foundation year) BSc (Hons)</li><li>Banking and Finance BSc (Hons)</li><li>Beauty Marketing and Journalism BA (Hons)</li><li>Biochemistry (including foundation year) BSc (Hons)</li><li>Biochemistry BSc (Hons)</li><li>Biological Science (including foundation year) BSc (Hons)</li><li>Biological Science BSc (Hons)</li><li>Biology of Infectious Disease (including foundation year) BSc (Hons)</li><li>Biomedical Science (including foundation year) BSc (Hons)</li><li>Biomedical Science BSc (Hons)</li><li>Business Computer Systems (top-up) BSc (Hons)</li><li>Business Management (including foundation year) BA (Hons)</li><li>Business Management (Top-up) BA (Hons)</li><li>Business Management and Human Resource Management BA (Hons)</li><li>Business Management and Marketing (including foundation year) BA (Hons)</li><li>Business Management and Marketing BA\u00a0</li><li>Business Management BA\u00a0</li><li>Chemistry (including foundation year) BSc (Hons)</li><li>Chemistry BSc (Hons)</li><li>Community Development and Leadership (including foundation year) BSc (Hons)</li><li>Community Development and Leadership BSc (Hons)</li><li>Computer Networking and Cloud Security (including foundation year) BEng (Hons)</li><li>Computer Networking and Cloud Security BEng (Hons)</li><li>Computer Networking and Cyber Security (including foundation year) BSc (Hons)</li><li>Computer Networking and Cyber Security BSc (Hons)</li><li>Computer Networking and Infrastructure Security (including foundation year) BEng\u00a0</li><li>Computer Networking and Infrastructure Security BEng\u00a0</li><li>Computer Science (including foundation year) BSc (Hons)</li><li>Computer Science BSc (Hons)</li><li>Computer Systems Engineering and Robotics (including foundation year) BEng (Hons)</li><li>Computer Systems Engineering and Robotics BEng\u00a0</li><li>Computing (including foundation year) BSc (Hons)</li><li>Computing BSc (Hons)</li><li>Construction Management BSc (Hons)</li><li>Counselling and Coaching BSc (Hons)</li><li>Counselling BSc (Hons)</li><li>Creative Writing and English Literature (including foundation year) BA (Hons)</li><li>Creative Writing and English Literature BA\u00a0</li><li>Criminology (including foundation year) BSc (Hons)</li><li>Criminology and International Security BA\u00a0</li><li>Criminology and Law BA\u00a0</li><li>Criminology and Policing BSc (Hons)</li><li>Criminology and Psychology BSc (Hons)</li><li>Criminology and Sociology BSc (Hons)</li><li>Criminology and Youth Studies BSc (Hons)</li><li>Criminology BSc (Hons)</li><li>Cyber Security and Forensic Computing (Top-up) BSc (Hons)</li><li>Data Science (including foundation year) BSc (Hons)</li><li>Data Science BSc (Hons)</li><li>Dietetics and Nutrition BSc (Hons)</li><li>Dietetics BSc (Hons)</li><li>Digital Business Management BSc (Hons)</li><li>Digital Forensics and Cyber Security (including foundation year) BSc (Hons)</li><li>Digital Forensics and Cyber Security BSc (Hons)</li><li>Digital Media (including foundation year) BA (Hons)</li><li>Digital Media BA\u00a0</li><li>Diplomacy and International Relations BA\u00a0</li><li>Early Childhood Studies (including foundation year) BA (Hons)</li><li>Early Childhood Studies (Top-Up) BA (Hons)</li><li>Early Childhood Studies BA\u00a0</li><li>Economics (including foundation year) BSc (Hons)</li><li>Economics and Finance BSc (Hons)</li><li>Economics BSc (Hons)</li><li>Economics, Finance and International Business BSc (Hons)</li><li>Education (including foundation year) BA (Hons)</li><li>Education BA (Hons)</li><li>Education Studies and English Literature BA\u00a0</li><li>Education Studies BA\u00a0</li><li>Electronic Engineering and Internet of Things (including foundation year) BEng (Hons)</li><li>Electronic Engineering and Internet of Things BEng (Hons)</li><li>Electronics and Internet of Things (including foundation year) BEng (Hons)</li><li>Electronics and Internet of Things BEng (Hons)</li><li>English Literature BA\u00a0</li><li>Events Management (including foundation year) BA (Hons)</li><li>Events Management and Marketing BA (Hons)</li><li>Events Management BA\u00a0</li><li>Examination in Professional Practice in Architecture (RI 3) BA\u00a0</li><li>Fashion (including foundation year) BA (Hons)</li><li>Fashion (Top-Up) BA (Hons)</li><li>Fashion Accessories and Jewellery BA\u00a0</li><li>Fashion BA\u00a0</li><li>Fashion Marketing and Business Management BA\u00a0</li><li>Fashion Marketing and Journalism (including foundation year) BA (Hons)</li><li>Fashion Marketing and Journalism BA (Hons)</li><li>Fashion Photography (including foundation year) BA (Hons)</li><li>Fashion Photography BA\u00a0</li><li>Fashion Textiles (including foundation year) BA (Hons)</li><li>Fashion Textiles BA (Hons)</li><li>Film and Television Production (including foundation year) BA (Hons)</li><li>Film and Television Production BA\u00a0</li><li>Film and Television Studies (including foundation year) BA (Hons)</li><li>Film and Television Studies BA\u00a0</li><li>Fine Art (including foundation year) BA (Hons)</li><li>Fine Art (Top-up) BA (Hons)</li><li>Fine Art BA\u00a0</li><li>Forensic Science (including foundation year) BSc (Hons)</li><li>Furniture and Product Design (including foundation year) BA (Hons)</li><li>Furniture and Product Design BA\u00a0</li><li>Games Animation, Modelling and Effects (including foundation year) BSc (Hons)</li><li>Games Animation, Modelling and Effects BSc (Hons)</li><li>Games Programming (including foundation year) BSc (Hons)</li><li>Games Programming BSc (Hons)</li><li>Graphic Design (including foundation year) BA (Hons)</li><li>Graphic Design (with preparatory semester) BA (Hons)</li><li>Graphic Design BA\u00a0</li><li>Health and Social Care (including foundation year) BSc (Hons)</li><li>Health and Social Care (Top-up) BSc (Hons)</li><li>Health and Social Care BSc (Hons)</li><li>Herbal Medicinal Science (Top-Up) BSc (Hons)</li><li>Human Nutrition (including foundation year) BSc (Hons)</li><li>Human Nutrition BSc (Hons)</li><li>Illustration and Animation (including foundation year) BA (Hons)</li><li>Illustration and Animation (with preparatory semester) BA (Hons)</li><li>Illustration and Animation BA\u00a0</li><li>Interior Architecture and Design (including foundation year) BA (Hons)</li><li>Interior Architecture and Design (Top-up) BA (Hons)</li><li>Interior Architecture and Design (with preparatory semester) BA (Hons)</li><li>Interior Architecture and Design BA\u00a0</li><li>Interior Design (including foundation year) BA (Hons)</li><li>Interior Design (with preparatory semester) BA (Hons)</li><li>Interior Design and Decoration (including foundation year) BA (Hons)</li><li>Interior Design and Decoration BA\u00a0</li><li>Interior Design BA\u00a0</li><li>International Business Management (including foundation year) BSc (Hons)</li><li>International Business Management (Top-Up) BSc (Hons)</li><li>International Business Management BSc (Hons)</li><li>International Foundation Programme &#8211; Computer Science BSc (Hons)</li><li>International Relations (including foundation year) BA (Hons)</li><li>International Relations and Law BA\u00a0</li><li>International Relations and Politics BA\u00a0</li><li>International Relations BA\u00a0</li><li>International Relations with Arabic BA\u00a0</li><li>International Relations with Languages BA\u00a0</li><li>International Relations, Peace and Conflict Studies BA\u00a0</li><li>Journalism (including foundation year) BA (Hons)</li><li>Journalism BA (Hons)</li><li>Journalism, Film and Television Studies (including foundation year) BA (Hons)</li><li>Journalism, Film and Television Studies BA (Hons)</li><li>Law (Criminal Law) LLB\u00a0</li><li>Law (including foundation year) BA (Hons)</li><li>Law (Top-Up) (Distance Learning) LLB\u00a0</li><li>Law (with International Relations) LLB\u00a0</li><li>Law BA\u00a0</li><li>Law LLB\u00a0</li><li>Leadership in Communities (including foundation year) BSc (Hons)</li><li>Leadership in Communities BSc (Hons)</li><li>MArch Architecture RI 2 BA\u00a0</li><li>Marketing (including foundation year) BA (Hons)</li><li>Marketing BA\u00a0</li><li>Mathematical Sciences (including foundation year) BSc (Hons)</li><li>Mathematics (including foundation year) BSc (Hons)</li><li>Mathematics BSc (Hons)</li><li>Media and Communications (including foundation year) BSc (Hons)</li><li>Media and Communications BSc (Hons)</li><li>Media and Marketing BA\u00a0</li><li>Media with Arabic BA\u00a0</li><li>Media, Communications and Journalism BSc (Hons)</li><li>Medical Bioscience (including foundation year) BSc (Hons)</li><li>Medical Bioscience BSc (Hons)</li><li>Music Business (including foundation year) BA (Hons)</li><li>Music Business and Live Entertainment BA\u00a0</li><li>Music Business BA (Hons)</li><li>Music Technology and Production (including foundation year) BSc (Hons)</li><li>Music Technology and Production BSc (Hons)</li><li>Natural Sciences (Biology) (including foundation year) BSc (Hons)</li><li>Natural Sciences (Biology) BSc (Hons)</li><li>Nursing (Adult) BSc (Hons)</li><li>PG Certificate Professional Practice in Architecture (RI 3) BA\u00a0</li><li>Pharmaceutical Science (including foundation year) BSc (Hons)</li><li>Pharmaceutical Science BSc (Hons)</li><li>Pharmacology (including foundation year) BSc (Hons)</li><li>Pharmacology BSc (Hons)</li><li>Photography (including foundation year) BA (Hons)</li><li>Photography (Top-up) BA (Hons)</li><li>Photography BA\u00a0</li><li>Photojournalism BA (Hons)</li><li>Police Studies, Procedure and Investigation (including foundation year) BSc (Hons)</li><li>Police Studies, Procedure and Investigation BSc (Hons)</li><li>Politics (including foundation year) BA (Hons)</li><li>POLITICS BA\u00a0</li><li>Primary Education (two-year accelerated degree) BA (Hons)</li><li>Product and Furniture Design (including foundation year) BA (Hons)</li><li>Product and Furniture Design BA (Hons)</li><li>Psychology (including foundation year) BSc (Hons)</li><li>Psychology and Sociology BSc (Hons)</li><li>Psychology BSc (Hons)</li><li>Public Health and Health Promotion (Top-Up) BSc (Hons)</li><li>Quantity Surveying and Commercial Management BSc (Hons)</li><li>Social Work (including foundation year) BSc (Hons)</li><li>Social Work BSc (Hons)</li><li>Social Work Extended Degree(Inc Foundation Yr) BSc (Hons)</li><li>Sociology (including foundation year) BSc (Hons)</li><li>Sociology and Social Policy BSc (Hons)</li><li>Sociology BSc (Hons)</li><li>Software Engineering (Top-Up) BEng\u00a0</li><li>Sport and Exercise Science (including foundation year) BSc (Hons)</li><li>Sport and Exercise Science BSc (Hons)</li><li>Sport Psychology, Coaching and Physical Education (including foundation year) BSc (Hons)</li><li>Sport Psychology, Coaching and Physical Education BSc (Hons)</li><li>Sports and Dance Therapy BSc (Hons)</li><li>Sports Therapy (including foundation year) BSc (Hons)</li><li>Sports Therapy BSc (Hons)</li><li>Textiles (including foundation year) BA (Hons)</li><li>Textiles BA (Hons)</li><li>Theatre and Film (Top-Up) BA (Hons)</li><li>Theatre and Film BA\u00a0</li><li>Theatre and Performance (Top-up) BA (Hons)</li><li>Theatre and Performance BA (Hons)</li><li>Tourism and Travel Management (including foundation year) BA (Hons)</li><li>Tourism and Travel Management (Top-up) BA (Hons)</li><li>Tourism and Travel Management BA\u00a0</li><li>Youth Justice BA (Hons)</li><li>Youth Studies (including foundation year) BSc (Hons)</li><li>Youth Studies BSc (Hons)</li><li>Youth Work (with JNC Recognition) BSc (Hons)</li></ul>\u00a0\n\t\t\t<a href=\"http://More%20Info%20on%20Undergraduate%20Degrees\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p style=\"margin-bottom: 0in; background: white;\">Bachelor\u2019s Degree GPA of 2.7+ and 30+ credits in relevant subject area.</p><p>\u00a0</p><p style=\"margin-bottom: 0in; background: white;\">No tests required</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t\u00a0<ul><li>Advanced Diploma in Professional Development in Employment Law and Practice\u00a0</li><li>Airline and Airport Corporate Management MSc</li><li>Approved Mental Health Practice PG Certificate</li><li>Arabic Language Teaching MA</li><li>Artificial Intelligence MSc</li><li>Aviation Management in the Digital Age MSc</li><li>Barrister to Solicitor LPC PGD</li><li>Biomedical Science On-line\u00a0</li><li>Biomedical Sciences MSc</li><li>Biomedical Studies (Distance Learning) MSc</li><li>Blood Science (Distance Learning) MSc</li><li>Blood Science MSc</li><li>Cancer Immunotherapy MSc</li><li>Cancer Pharmacology MSc</li><li>Child and Adolescent Mental Health MSc</li><li>CISCO Certified Networking Associate Training (CCNA)\u00a0</li><li>Cognitive Behavioural Therapy MSc</li><li>Common Professional Exam\u00a0</li><li>Computer Networking and Cyber Security MSc</li><li>Computer Networking and Cyber Security with Work Experience MSc</li><li>Conference Interpreting MA</li><li>Construction Project Management MSc</li><li>Continuing Professional Development for Social Work\u00a0</li><li>Corporate Social Responsibility and Sustainability MSc</li><li>Counselling and Psychotherapy MSc</li><li>Creative, Digital and Professional Writing MA</li><li>Crime, Violence and Prevention MSc</li><li>Criminology and Psychopathology MSc</li><li>Criminology MSc</li><li>Cryptography MSc</li><li>Data Analytics MSc</li><li>Design for Cultural Commons PG Cert</li><li>Dietetics and Nutrition MSc</li><li>Digital Media MA</li><li>Diploma Conference Interpreting PG</li><li>Diploma Step Up to Social Work PG</li><li>Diploma Translation PG</li><li>Doctor of Business Administration\u00a0</li><li>Doctor of Education\u00a0</li><li>Documentary Film Production MA</li><li>Dprof Crime, Policy and Security\u00a0</li><li>Early Childhood Studies MA</li><li>Education MA</li><li>English Language Teaching (Distance Learning) MA</li><li>English Language Teaching MA</li><li>Environmental, Sustainable and Regeneration Design MA</li><li>Fashion Marketing and Management MA</li><li>Food Science MSc</li><li>Forensic Science\u00a0</li><li>Global Human Resource Management MA</li><li>Health and Social Care Leadership and Management MSc</li><li>Health and Social Care Management and Policy MSc</li><li>Human Nutrition (Public Health/Sports) MSc</li><li>Human Nutrition MSc</li><li>Human Resource Management MA</li><li>Human Rights and International Conflict MA</li><li>Human Rights Law LLM</li><li>Information Technology (Distance Learning) MSc</li><li>Initial Teacher Training Mentoring and Teacher Development\u00a0</li><li>Interior Design MA</li><li>International Accounting and Finance MSc</li><li>International Banking and Finance MSc</li><li>International Business Management MSc</li><li>International Business Management with Project Management MSc</li><li>International Events, Leisure and Tourism Management MSc</li><li>International Relations MA</li><li>International Security Studies MA</li><li>International Trade and Finance MSc</li><li>Interpreting MA</li><li>Jewellery and Silversmithing MA</li><li>Learning and Teaching in Higher Education MA</li><li>Legal Practice (Top-up) LLM</li><li>Legal Practice Course PGD</li><li>Legal Practice LLM</li><li>Marketing MA</li><li>Master of Business Administration MBA</li><li>Master of Fine Arts MFA</li><li>Master of Philosophy Art\u00a0</li><li>Master of Public Administration (MPA)\u00a0</li><li>Mathematical Sciences\u00a0</li><li>Medical Genomics MSc</li><li>Modern and Traditional Upholstery\u00a0</li><li>Organised Crime and Global Security MA</li><li>Peace, Conflict and Diplomacy MA</li><li>Pharmaceutical Science and Drug Delivery Systems MSc</li><li>Pharmaceutical Science MSCi</li><li>Physiotherapy (Pre-registration) MSc</li><li>Political Violence and Radicalisation Studies MSc</li><li>Postgraduate Diploma Global Human Resource Management\u00a0</li><li>Postgraduate Teacher Apprenticeship (PGTA) in Primary (3 \u2013 7) with QTS and PGCE\u00a0</li><li>Postgraduate Teacher Apprenticeship (PGTA) in Primary (5 \u2013 11) with QTS and PGCE\u00a0</li><li>Practice Education (Stages 1 and 2)\u00a0</li><li>Primary (3-7) PGCE</li><li>Primary (5-11) PGCE</li><li>Primary (7-11) (Key Stage 2)\u00a0</li><li>Primary Apprenticeship (3-7) (Primary Advantage) PGCE</li><li>Primary Apprenticeship (5-11) (Primary Advantage) PGCE</li><li>Primary Apprenticeship (5Wells Development Centre) PGCE</li><li>Primary Apprenticeship (Hackney Teaching Schools Alliance) PGCE</li><li>Product Design MA</li><li>Professional Course in Purchasing and Supply\u00a0</li><li>Professional Doctorate in Counselling Psychology\u00a0</li><li>Professional Doctorate in Health Psychology\u00a0</li><li>Professional Doctorate in Policing, Security and Community Safety\u00a0</li><li>Psychology MSc</li><li>Psychology of Mental Health MSc</li><li>Public Art and Performance MA</li><li>Public Health MSc</li><li>Quantity Surveying MSc</li><li>Real Estate MSc</li><li>Refugee Healthcare Professionals Programme\u00a0</li><li>Research Degree\u00a0</li><li>Robotics with Artificial Intelligence MSc</li><li>School Direct Primary (Viridis) PGCE</li><li>Secondary Computer Science with ICT PGCE</li><li>Secondary English with Drama PGCE</li><li>Secondary English with Media PGCE</li><li>Secondary Mathematics PGCE</li><li>Secondary Modern Languages PGCE</li><li>Secondary Science with Biology PGCE</li><li>Secondary Science with Chemistry PGCE</li><li>Secondary Science with Physics PGCE</li><li>Sexual Violence: Causes, Consequences and Interventions\u00a0</li><li>Social Work MSc</li><li>Sports Therapy MSc</li><li>Teacher Apprenticeship Orchard Primary School (Viridis Schools) PGCE</li><li>Teaching Languages (English) MA</li><li>The Open Language Programme\u00a0</li><li>Translation\u00a0</li><li>Translation MA</li><li>Translation Technology PG Certificate</li><li>Violence Against Women: Issues, Research and Policy\u00a0</li><li>Visual Communication: Graphic Design MA</li><li>Visual Communication: Illustration MA</li><li>Woman and Child Abuse MA</li><li>Youth and Community Work (with JNC Recognition) MSc</li></ul><p>\u00a0</p>\n\t\t\t<a href=\"http://www.londonmet.ac.uk/courses/postgraduate/\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"http://www.facebook.com/londonmetuni/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://twitter.com/LondonMetUni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.instagram.com/londonmetuni/?hl=en\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.youtube.com/user/LondonMetUniversity\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.londonmet.ac.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.londonmet.ac.uk/international/applying/countries/students-from-the-usa/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.londonmet.ac.uk/applying/funding-your-studies/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.londonmet.ac.uk/applying/funding-your-studies/scholarships/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.londonmet.ac.uk/applying/funding-your-studies/loans/us-financial-aid/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.londonmet.ac.uk/international/applying/meet-us-overseas/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.londonmet.ac.uk/research/courses/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.londonmet.ac.uk/services-and-facilities/accommodation/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.londonmet.ac.uk/services-and-facilities/employment-support/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.londonmet.ac.uk/services-and-facilities/students-union/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"http://www.londonmet.ac.uk/applying/\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"London Metropolitan University","post_link":"https://theukstudyexpert.com/universities/londonmet/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"London Metropolitan University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/London-Metropolitan-University-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"London, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10237,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"University of Chester","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Chester\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Chester-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/chester/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Chester</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Proudly welcoming over 14,000 students from 115 countries worldwide, The University of Chester provides a vibrant, diverse and safe home for students. \r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Proudly welcoming over 14,000 students from 115 countries worldwide, The University of Chester provides a vibrant, diverse and safe home for students. ","address":"Parkgate Rd, Chester CH1 4BJ, UK","location":{"lat":"53.2002807","state":"England","country":"United Kingdom","lng":"-2.8998193","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/chester/","zoom":5,"extra_fields":{"post_excerpt":"Proudly welcoming over 14,000 students from 115 countries worldwide, The University of Chester provides a vibrant, diverse and safe home for students. ","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/aa.png\" alt=\"University of Chester\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/aa-1.png\" alt=\"University of Chester\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/aa-2.png\" alt=\"University of Chester\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/aa-3.png\" alt=\"University of Chester\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/aa-4.png\" alt=\"University of Chester\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/aa-5.png\" alt=\"University of Chester\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact University of Chester\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> Parkgate Road, Chester, England, CH1 4BJ, United Kingdom</p><p><strong>Website:</strong> <a href=\"https://www.chester.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://chester.ac.uk/</a></p><h3>Overview</h3><p>Proudly welcoming over 14,000 students from 115 countries worldwide, The University of Chester provides a vibrant, diverse and safe home for students. The University is one of the oldest higher education providers in the United Kingdom having recently celebrated its 182nd year of teaching, starting off as a teacher training college back in 1839. Originally based on one campus in Chester, the University now offers more than 200 single and combined honours programmes across a number of specialist sites in Chester, Shrewsbury and Warrington. Courses have an emphasis on practical learning to enhance prospects via industry placements or overseas opportunities, ranging from five-weeks to one-year.</p><p data-rte-preserve-empty=\"true\">\u00a0</p><p>In 2020, the University was voted second-best in the UK for international students at the WhatUni? Student Choice Awards. This national recognition, based on the reviews of our students, is testament to our commitment to providing students with an outstanding learning and social experience.</p><p data-rte-preserve-empty=\"true\">\u00a0</p><p><strong>Population: </strong>14,000</p><p><strong>Campus Type: </strong>Urban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li><p>The University is one of the oldest higher education providers in the United Kingdom having recently celebrated its 182nd year of teaching.</p></li><li><p>The University offer a diverse range of International and Merit-Based Scholarships.</p></li><li><p>Most of our Undergraduate degrees include a five-week work placement in second year that students can complete in any business across the world!</p></li><li><p>The University of Chester offer accredited courses that provide students with a guarantee of quality and can count towards professional qualifications or registration with a professional body.</p></li><li><p>\u00a34 million has been invested in the University of Chester award-winning Business School, and on-site learning facilities including modern computer suites and a dedicated business library with group study spaces and learning pods for quiet study.</p></li></ul>\t\t\n\t\t<h3>Videos</h3>https://youtu.be/y_7Ta-HZoF0https://www.youtube.com/watch?v=jK0deWoDse4https://youtu.be/gregGKXeSyw\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p>Year 1 Entry:</p><p><br />High School Diploma with 3.5 GPA (no other qualifications needed) <br /><br /><strong>OR</strong><br /><br />High School diploma (or equivalent) with a GPA 3.0 PLUS one of the following:<br /><br /></p><ul><li>SAT (taken prior to March 2016) with an overall grade of 1500 (including reading, writing and math)</li><li>SAT (taken after March 2016) with an overall grade of 1090 (including 550 in reading/writing and math)</li><li>ACT with an overall grade of 22</li><li>2 AP Tests in relevant subject with grades 3 or above</li><li>2 High School Honours Classes or Advanced Placement (AP) classes with B Grades</li><li>2 College Level classes with B Grades</li><li>2 semesters of Community College with B Grades<br /><br /></li></ul><p><strong>Year 2 Entry:</strong><br /><br />Associate degree in relevant subject areas with a 3.0 GPA or above.<br /><br /></p><p><em>Engineering courses require an additional mark of at least 55% in a Maths module.</em></p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Animal Behaviour</li><li>Animal Behaviour and Welfare</li><li>Fashion Design</li><li>Fine Art</li><li>Graphic Design</li><li>Interior Design</li><li>Photography</li><li>Product Design</li><li>Biology</li><li>Biovetinary Science</li><li>Forensic Biology</li><li>Marine Biology</li><li>Zoology</li><li>Accounting and Finance</li><li>Banking and Finance</li><li>Business Finance</li><li>Business Management</li><li>Business Management and Administration (Level 6 Top-up)</li><li>Business Management with Specialisms</li><li>Digital Marketing</li><li>Events and Festivals Management</li><li>Events Management</li><li>lnternational Business Management</li><li>International Business Management with a Language</li><li>International Tourism Management</li><li>Marketing Management</li><li>Computer Science</li><li>Cybersecurity</li><li>Games Development</li><li>Software Engineering</li><li>Childhood Studies with Applied Psychology</li><li>Early Childhood Studies</li><li>Early Years &#8211; Primary Education (3-7) with QTS \u2013 Teacher Education</li><li>Education Studies</li><li>Primary Education (5-11) with QTS \u2013 Teacher Education</li><li>Special Educational Needs and Disabilities</li><li>Chemical Engineering</li><li>Creative Writing</li><li>English Language</li><li>English Language and Literature</li><li>English Literature</li><li>Human Nutrition</li><li>Nutrition and Exercise Science</li><li>Geography</li><li>Natural Hazard Management</li><li>Midwifery</li><li>Social Work</li><li>Archaeology</li><li>History</li><li>Chinese</li><li>French</li><li>German</li><li>Modern Languages</li><li>Spanish</li><li>Spanish, Portuguese and Latin American Studies</li></ul><ul id=\"majors\"><li>Law (Combined)</li><li>Law (LLB)</li><li>Film and Media Studies</li><li>Journalism</li><li>Media and Television Production</li><li>Music Journalism</li><li>Sports Journalism</li><li>Biomedical Science</li><li>Bioscience</li><li>Biotechnology</li><li>Health and Exercise Science</li><li>Medical Science</li><li>Medicine MB ChB (Graduate Entry)</li><li>Microbiology</li><li>Pharmacology</li><li>Chemistry</li><li>Physics</li><li>Acting</li><li>Drama</li><li>Music Production</li><li>Music Production and Performance</li><li>Musical Theatre</li><li>Performing Arts</li><li>Popular Music Performance</li><li>Applied Psychology</li><li>Community Policing and Criminal Investigation</li><li>Counselling Skills</li><li>Criminology</li><li>Economics</li><li>Forensic Psychology</li><li>International Relations</li><li>Politics</li><li>Psychology</li><li>Sociology</li><li>Social Justice and Community Action</li><li>Physical Education</li><li>Sport Management</li><li>Sports Coaching</li><li>Sport and Exercise Sciences</li><li>Theology and Religious Studies</li><li>Philosophy, Ethics and Religion</li></ul>\n\t\t\t<a href=\"http://www1.chester.ac.uk/international/courses/undergraduate\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3>\n<h4>US Entry Requirements</h4>\n<p>Bachelor's Degree from a recognized institution with 3.0 or above.</p>\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Animal Behaviour</li><li>Animal Welfare</li><li>Wildlife Conservation</li><li>Design</li><li>Biological Sciences</li><li>Marine and Coastal Resource Management</li><li>Digital Marketing</li><li>Engineering Management</li><li>Health Services Management</li><li>International Business</li><li>International Finance</li><li>Management</li><li>Marketing Management</li><li>MBA</li><li>Banking and Finance</li><li>Accounting</li><li>Advanced Computer Science</li><li>Applied Science</li><li>Computer Science (Conversion)</li><li>Cybersecurity (Conversion)</li><li>Data Science</li><li>Education in Society</li><li>Postgraduate Certificate in Education (PGCE) Early Years</li><li>Postgraduate Certificate in Education (PGCE) Primary</li><li>Postgraduate Certificate in Education (PGCE) Secondary</li><li>Educational Leadership</li><li>Electrical and Electronic Engineering</li><li>Mechanical Engineering</li><li>Programme and Project Management</li><li>Creative Writing: Writing and Publishing Fiction</li><li>English</li><li>English Language and Linguistics</li><li>Gender Studies</li><li>Nineteenth-Century Literature and Culture</li><li>Storytelling</li><li>Clinical Sciences and Nutrition</li><li>Exercise and Nutrition Science</li><li>Food Science and Innovation</li><li>Human Nutrition</li><li>Obesity and Weight Management</li><li>Public Health Nutrition</li><li>Flood Risk Assessment, Modelling and Engineering</li><li>Art Therapy</li><li>Doctor of Public Health</li><li>Master of Public Health</li><li>Pre-Registration Adult Nursing</li><li>Pre-registration Mental Health Nursing</li><li>Social Work</li><li>Archaeology and Heritage Practice</li><li>Archaeology of Death and Memory</li></ul><ul id=\"majors\"><li>History</li><li>Military History</li><li>Museums and Heritage Practice</li><li>War, Conflict and Society</li><li>Languages Cultures and Translation</li><li>TESOL (Teaching English to Speakers of Other Languages)</li><li>Mathematics</li><li>Arts and Media</li><li>Journalism</li><li>Biomedical Science</li><li>Biotechnology</li><li>Cardiovascular Disease</li><li>Cardiovascular Health and Rehabilitation</li><li>Diabetes</li><li>Exercise Medicine</li><li>Haematology</li><li>Infection and Immunity</li><li>Medical Genetics</li><li>Medical Science</li><li>Oncology</li><li>Orthopaedics</li><li>Physician Associate Studies</li><li>Psychiatry</li><li>Respiratory Medicine</li><li>Stem Cells and Regenerative Medicine</li><li>Graduate Entry Medicine</li><li>Applied Science</li><li>Dance</li><li>Drama</li><li>Popular Music</li><li>Applied Psychology</li><li>Family and Child Psychology</li><li>Policing, Law Enforcement and Security</li><li>Psychology (Conversion)</li><li>Sociology of Sport and Exercise</li><li>Sport Coaching and Development</li><li>Sports Medicine</li><li>Sports Performance Analysis</li><li>Sports Performance Science</li><li>Sports Biomechanics</li><li>Theology and Religious Studies</li></ul>\n\t\t\t<a href=\"http://www1.chester.ac.uk/international/courses/postgraduate\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"http://www.facebook.com/UoCInternational\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://twitter.com/UoCInter\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.instagram.com/uocinternational/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.youtube.com/c/universityofchester/featured\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www1.chester.ac.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www1.chester.ac.uk/international/your-country/united-states\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www1.chester.ac.uk/international/fees-scholarships-and-finance/tuition-fees\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www1.chester.ac.uk/international/fees-scholarships-and-finance/scholarships\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www1.chester.ac.uk/us-financial-aid\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www1.chester.ac.uk/undergraduate/undergraduate-visits/undergraduate-virtual-events\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www1.chester.ac.uk/international/courses/research-degrees\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www1.chester.ac.uk/undergraduate/accommodation/accommodation-chester/accommodation-options\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www1.chester.ac.uk/careers-and-employability\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.chestersu.com/groups\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"http://www1.chester.ac.uk/international/how-apply\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"University of Chester","post_link":"https://theukstudyexpert.com/universities/chester/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Chester\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Chester-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"Chester, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10235,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Arts University Bournemouth","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Arts University Logo\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Arts-University-Logo-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/arts-university-bournemouth/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Arts University Bournemouth</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Established in 1885, Arts University Bournemouth (AUB) is a specialist, public, British university where teaching and research is exclusively delivered in the areas of art, design, media, and performance.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Established in 1885, Arts University Bournemouth (AUB) is a specialist, public, British university where teaching and research is exclusively delivered in the areas of art, design, media, and performance.","address":"7 Fern Barrow, Wallisdown, Poole BH12 5HH, UK","location":{"lat":"50.7421804","state":"England","country":"United Kingdom","lng":"-1.8961949","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/arts-university-bournemouth/","zoom":5,"extra_fields":{"post_excerpt":"Established in 1885, Arts University Bournemouth (AUB) is a specialist, public, British university where teaching and research is exclusively delivered in the areas of art, design, media, and performance.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/aaa.png\" alt=\"Arts University Bournemouth\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/aaa-1.png\" alt=\"Arts University Bournemouth\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/aaa-2.png\" alt=\"Arts University Bournemouth\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/aaa-3.png\" alt=\"Arts University Bournemouth\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/aaa-4.png\" alt=\"Arts University Bournemouth\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/aaa-5.png\" alt=\"Arts University Bournemouth\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/aaa-6.png\" alt=\"Arts University Bournemouth\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact Arts University Bournemouth\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> Wallisdown Poole, Dorset, England, BH12 5HH, United Kingdom</p><p><strong>Website:</strong> <a href=\"https://www.aub.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://aub.ac.uk/</a></p><h3>Overview</h3><p>Established in 1880, Arts University Bournemouth (AUB) is a creative community where students and staff come together to innovate, collaborate and connect. We are a specialist, public, British university where teaching and research are exclusively delivered in the areas of art, design, media, and performance.</p><p>\u00a0</p><p>Our creative community is based on an award-winning campus with all the modern facilities and industry-standard equipment you need to achieve your goals. Preparation for a career in the creative sector will be the focus of studies; learning from tutors with extensive specialized experience and start to build a professional network.</p><p>\u00a0</p><p>In addition to hand-on studio-based culture, AUB offers ample opportunity to interact with industry in the form of live projects, work experience, study abroad, and participation in key industry events. You will leave AUB with industry connections and a portfolio of professional quality work that will help you set off on the successful path.</p><p>Arts University Bournemouth is home of the Bournemouth Film School \u2013 a collaborative learning environment designed to bring together all disciplines focused on screen work. The BFS is one small example of how collaboration is at the hear of everything we do.</p><p>\u00a0</p><p>Located on the south coast of England in a popular tourist destination, Bournemouth offers a great environment for study with an exceptional quality of life.</p><p>\u00a0</p><p><strong>Population:</strong> 4,000</p><p><strong>Campus Type:</strong> Suburban</p>\t\t\n\t\t<h3>Quick Facts</h3>\n<ul data-rte-list=\"default\">\n<li>\n<p>Founded in 1880</p>\n</li>\n<li>\n<p>Student population of 4000 - 18% international students</p>\n</li>\n<li>\n<p>AUB\u2019s post-graduate employment rate/further education rate of 93.5% (18 months after graduation).</p>\n</li>\n<li>\n<p>Well-known alumni include Director/Screenwriter Edgar Wright, Turner Prize-winning photographer Wolfgang Tillmans, The Great British Bake-Off illustrator Tom Hovey, and a few Oscar winners.</p>\n</li>\n</ul>\t\t\n\t\t<h3>Videos</h3>https://youtu.be/nQfO7Kmi_pQhttps://youtu.be/8EGXPBhwF1Mhttps://youtu.be/_L5GsxZ8J-k\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p>For direct admission, prospective applicants are urged to follow a college preparatory programme in high school, taking a senior course in fine or applied art where possible.<br /><br /></p><p>We'll accept any one of the following:<br /><br /></p><ul><li>Successful completion of an accredited honours or college preparatory high school diploma with a GPA of 3.0 or higher.</li><li>Successful completion of an accredited high school diploma with a GPA of 3.0 or above, plus one of the following:<ul><li>Two AP exam results with a grade of 3 or higher.</li><li>SAT I (Reasoning) scores of at least 1100.</li><li>SAT II subject tests in at least two subjects with minimum scores of 600.</li><li>Two or more IB Diploma Programme Courses.</li><li>ACT test results in at least two subjects with minimum scores of 24.</li><li>Successful completion of an accredited Associate\u2019s Degree.</li><li>Successful completion of first year (freshman year) of University at an accredited University.</li><li>Successful completion of a recognised Foundation Diploma in Art and Design Studies.</li></ul></li></ul><p><br />We will consider applicants who present a US high school diploma but who have not completed additional SAT, ACT, or AP exams. Applicants without those external exams will still be considered on the strength of their portfolio/audition and/or personal statements and are expected to demonstrate a profile of academics and experience related to the creative arts.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>BA (Hons) Acting</li><li>BA (Hons) Animation Production</li><li>BA (Hons) Architecture (ARB/RIBA Part 1)</li><li>BA (Hons) Commercial Photography</li><li>BA (Hon) Communication Design and Strategy</li><li>BA (Hons) Costume</li><li>BA (Hons) Creative Writing</li><li>BA (Hons) Events Management</li><li>BA (Hons) Fashion</li><li>BA (Hons) Fashion Branding and Communication</li><li>BA (Hons) Film Production</li></ul><ul id=\"majors\"><li>BA (Hons) Fine Art</li><li>BA (Hon) Games Art and Design</li><li>BA (Hons) Graphic Design</li><li>BA (Hons) Illustration</li><li>BA (Hons) Interior Architecture and Design</li><li>BA (Hons) Make-Up for Media and Performance</li><li>BA (Hons) Modelmaking</li><li>BA (Hons) Performance Design and Film Costume</li><li>BA (Hons) Photography</li><li>BA (Hons) Textiles</li><li>BA (Hons) Visual Effects (VFX) for Film and Television</li></ul>\n\t\t\t<a href=\"http://www.aub.ac.uk/#undergraduate\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>You will usually have BA (Hons) Degree graded at 2.1 (generally equivalent to a CGPA of 3.0) or above, or an equivalent UK or international qualification in your chosen subject or a related discipline. <br /><br />We encourage application from students with a broad range of qualifications and we welcome students from all educational backgrounds. We will take into account the knowledge and skills that you have developed outside the classroom as well as your previous qualifications.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Master of Architecture (Part 2 ARB/RIBA)</li><li>MA Animation Production</li><li>MA Digital Fashion Innovation</li><li>MA Film Practice</li><li>MA Fine Art</li></ul><ul id=\"majors\"><li>MA Graphic Design</li><li>MA Historical Costume</li><li>MA Illustration</li><li>MA Painting</li><li>MA Photography</li><li>M Research Arts</li></ul>\n\t\t\t<a href=\"http://www.aub.ac.uk/#postgraduate\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"http://www.facebook.com/inspiredAUB/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://twitter.com/inspiredAUB\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.instagram.com/inspiredaub\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.youtube.com/inspiredaub\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"http://www.aub.ac.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://aub.ac.uk/international/your-country-region/america\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"http://www.aub.ac.uk/fees/undergraduate#tab-833448-international-eu\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://aub.ac.uk/international/eu-and-international-scholarships\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://aub.ac.uk/international/american-loans\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://aub.ac.uk/international/virtual-creative-workshops\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://aub.ac.uk/our-research\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://aub.ac.uk/accommodation\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://aub.ac.uk/careers-and-enterprise\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.aubsu.co.uk/activities/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"http://www.aub.ac.uk/apply/undergraduate\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"Arts University Bournemouth","post_link":"https://theukstudyexpert.com/universities/arts-university-bournemouth/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Arts University Logo\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Arts-University-Logo-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.4-2.59, 2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Creativeperforming Arts Design, England","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"2.4-2.59, 2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Creativeperforming Arts Design, England","city_country":"Poole. England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10233,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"University of Roehampton","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Roehampton\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Roehampton-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/roehampton/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Roehampton</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Situated on a beautiful parkland campus in the heart of south-west London, the University of Roehampton has a proud history stretching back 180 years through its four colleges.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Situated on a beautiful parkland campus in the heart of south-west London, the University of Roehampton has a proud history stretching back 180 years through its four colleges.","address":"Roehampton Ln, London SW15 5PH, UK","location":{"lat":"51.4563401","state":"England","country":"United Kingdom","lng":"-0.2446496","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/roehampton/","zoom":5,"extra_fields":{"post_excerpt":"Situated on a beautiful parkland campus in the heart of south-west London, the University of Roehampton has a proud history stretching back 180 years through its four colleges.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/b.png\" alt=\"University of Roehampton\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/b-1.png\" alt=\"University of Roehampton\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/b-2.png\" alt=\"University of Roehampton\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/b-3.png\" alt=\"University of Roehampton\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/b-4.png\" alt=\"University of Roehampton\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/b-5.png\" alt=\"University of Roehampton\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact University of Roehampton\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> Roehampton Ln, London SW15 5PU, UK</p><p><strong>Website:</strong> <a href=\"https://roehampton.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://roehampton.ac.uk/</a></p><h3>Overview</h3><p>Situated on a beautiful parkland campus in the heart of south-west London, the University of Roehampton has a proud history stretching over 180 years through its four colleges. Our Whitelands College was the first college of higher education in the UK to admit women in 1841. <br /><br />Roehampton has a diverse community of 9,000 students from more than 146 countries. The University offers a range of course choices across 6 different academic departments and schools, and is highly regarded in the areas of Dance, History, Psychology, Liberal Arts and English Literature programmes. <br /><br />The University of Roehampton focuses on creating new knowledge and ideas that help to understand our world and make it a better place; it is jointly recognised as the best modern university in the country, and best modern university in London for research excellence. 77% of the university\u2019s research is officially recognised as of world-class standard.<br /><br /></p><p><strong>Population: </strong>9,000</p><p><strong>Campus Type: </strong>Suburban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li><p>Roehampton has been Crystal Palace F.C\u2019s Official Higher Education Partner as of 2021.</p></li><li><p>One of the first UK Schools to educate Women, and the first UK college to admit women in 1841.</p></li><li><p>The University of Roehampton has excellent facilities for students who are interested in esports and gaming, whether you are focussed on competitive games or just want to relax after lectures. We also offer advice and training for students interested in creating content, from live streaming to video production for YouTube and Twitch. We have a large and active esports society that competes in national esports tournaments.</p></li></ul>\t\t\n\t\t<h3>Videos</h3>https://youtu.be/HFbn-TqEPhchttps://youtu.be/NVe2_VEnN1chttps://youtu.be/88oVw_QdYW4https://youtu.be/VW_iq2LCZ0Ahttps://youtu.be/KLtsNfbg8fIhttps://youtu.be/aPunJKlPKoM\t\t\n\t\t<h3>Undergraduate Information</h3>A small number of bachelor programmes carry a subject specific requirement. Please check if this is the case, but subject specific requirements can be met by achieving at least grade B in relevant subject area(s) from 11th or 12th grade, ACT (26+), SAT (1100+) or two AP\u2019s (3+).\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Accounting</li><li>Accounting Studies</li><li>Adult and Mental Health Nursing</li><li>Adult Nursing</li><li>Anthropology</li><li>Biological Sciences</li><li>Biomedical Science</li><li>Business Management</li><li>Business Management (Top-up)</li><li>Business Management and Economics</li><li>Business Management and Economics (Top-up)</li><li>Business Management and Entrepreneurship</li><li>Business Management and Entrepreneurship (Top-up)</li><li>Business Management and Finance</li><li>Business Management and Finance (Top-up)</li><li>Business Management and Marketing</li><li>Business Management and Marketing (Top-up)</li><li>Classical Studies</li><li>Computer Science</li><li>Creative and Professional Writing</li><li>Criminology</li><li>Dance (BA)</li><li>Dance (BFA)</li><li>Digital Media</li><li>Diverse Dance Styles (IRIE!)</li><li>Drama, Theatre and Performance Studies</li><li>Early Childhood Studies</li><li>Education Practice</li><li>Education Studies</li><li>English Language and Linguistics</li><li>English Language and Literature</li><li>English Literature</li><li>English Literature and Philosophy</li><li>Film</li></ul><ul id=\"majors\"><li>History</li><li>History and Politics</li><li>Human Resource Management</li><li>Human Resource Management (Top-up)</li><li>International Business</li><li>International Business (Top-up)</li><li>International Business and Finance (Top-up)</li><li>JournalismLLB (Hons) Law</li><li>LLB (Hons) Law and Criminology</li><li>Marketing</li><li>Marketing (Top-up)</li><li>Media and Communications</li><li>Media, Culture and Identity</li><li>Mental Health Nursing</li><li>Ministerial Theology (FdA/BTh)</li><li>Nursing (Adult)</li><li>Nutrition and Health</li><li>Philosophy</li><li>Philosophy, Religion and Ethics</li><li>Photography</li><li>Primary Education (QTS)</li><li>Psychology</li><li>Psychology and Counselling</li><li>Psychology and Criminology</li><li>Sociology</li><li>Sociology and Social Anthropology</li><li>Sport and Exercise Sciences</li><li>Sport Coaching</li><li>Sport Psychology</li><li>Sports Coaching Practice</li><li>Sports Management</li><li>Therapeutic Psychology</li><li>Zoology</li></ul>\n\t\t\t<a href=\"https://www.roehampton.ac.uk/undergraduate-courses/\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><ul data-rte-list=\"default\"><li><p>Bachelor's degree minimum GPA 2.8 or 3.0, varies by programme</p><p data-rte-preserve-empty=\"true\">\u00a0</p></li><li><p>MBA:</p><p>Bachelor's degree minimum GPA 3.0 GMAT is considered, but not required</p></li></ul>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Applied Cognitive Neuroscience</li><li>Art Psychotherapy</li><li>Attachment Theory, Research and Practice</li><li>Audiovisual Translation</li><li>Cell Biomedicine (MRes)</li><li>Children&#8217;s Literature</li><li>Children&#8217;s Literature (Distance Learning)</li><li>Choreography (MFA)</li><li>Choreography and Performance (MRes)</li><li>Choreomundus: International Master in Dance Knowledge, Practice and Heritage</li><li>Classics and Ancient History</li><li>Clinical Neuroscience</li><li>Clinical Nutrition</li><li>Coaching and Mentoring in Education</li><li>Computing</li><li>Counselling Psychology (HCPC approved and BPS accredited)</li><li>Creative Writing</li><li>Creative Writing (specialist pathway)</li><li>Criminology and Criminal Justice</li><li>Dance Anthropology</li><li>Dance Movement Psychotherapy</li><li>Dance Philosophy and History</li><li>Dance Politics and Sociology</li><li>Dance Practice and Performance</li><li>Dance and Embodied Practice (MFA)</li><li>Digital Marketing</li><li>Dramatherapy</li><li>Early Childhood Studies</li><li>Ecology, Evolution and Behaviour</li><li>Education Leadership and Management</li><li>Education Studies</li><li>Educational Practice</li><li>Erasmus Mundus Human Rights Policy and Practice</li><li>Film Practices</li><li>Forensic Psychology</li><li>Global Business Management</li><li>Global Financial Management</li><li>Global Human Resources Management</li><li>Global Marketing</li><li>History (MA)</li><li>Human Rights and International Relations</li><li>Inclusive Education: SEN and Disability</li><li>Integrative Counselling and Psychotherapy</li></ul><ul id=\"majors\"><li>Integrative Counselling and Psychotherapy for Children, Adolescents and Families</li><li>Intercultural Communication in the Creative Industries</li><li>Journalism</li><li>LLM Human Rights and Legal Practice</li><li>LLM International Commercial Law and Legal Practice</li><li>London&#8217;s Theatre and Performance: Viewing, Making, Writing</li><li>MBA</li><li>MBA with placement year</li><li>Media Communication and Culture</li><li>Music and Children with Special Needs:Sounds of Intent</li><li>Music Therapy</li><li>National Award for SEN Coordinators</li><li>Nutrition and Metabolic Disorders (MRes)</li><li>Occupational and Business Psychology</li><li>Personal and Professional Development (recent Roehampton graduates only)</li><li>PGCE Primary</li><li>PGCE Secondary</li><li>Play Therapy</li><li>Popular Literature and Culture</li><li>Practical Philosophy</li><li>Practical Theology (DTh)</li><li>Primate Biology, Behaviour and Conservation</li><li>Project Management</li><li>Psychology (Conversion)</li><li>Psychology (Conversion) Distance Learning</li><li>Psychology of Forensic and Criminal Behaviour</li><li>Psychology of Sport and Exercise (BPS Accredited)</li><li>Publishing</li><li>School Direct &#8211; Primary and Secondary</li><li>Screenwriting</li><li>Social Research Methods</li><li>Spanish Language Teaching</li><li>Specialised Translation</li><li>Sport and Exercise Nutrition</li><li>Sport and Exercise Psychology (non-accredited)</li><li>Sport and Exercise Science (Pathways in Biomechanics or Physiology) (MSc)</li><li>Sport and Exercise Science (Pathways in Biomechanics, Physiology or Psychology) (MRes)</li><li>Strategic Business and Entrepreneurship</li><li>TESOL</li><li>Theology and Religious Studies</li><li>War Studies</li></ul>\n\t\t\t<a href=\"https://www.roehampton.ac.uk/postgraduate-courses/\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"http://www.facebook.com/roehamptonuni/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://twitter.com/RoehamptonUni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.instagram.com/uni_roehampton/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.youtube.com/c/RoehamptonAcUk/videos\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.roehampton.ac.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.roehampton.ac.uk/international/countries/united-states-of-america/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.roehampton.ac.uk/international/fees-and-support/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.roehampton.ac.uk/international/fees-and-support/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.roehampton.ac.uk/international/fees-and-support/us-student-loans/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.roehampton.ac.uk/events/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.roehampton.ac.uk/research/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.roehampton.ac.uk/accommodation/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.roehampton.ac.uk/careers/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.roehampton.ac.uk/student-life/our-campus/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"https://www.roehampton.ac.uk/how-to-apply/\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"University of Roehampton","post_link":"https://theukstudyexpert.com/universities/roehampton/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Roehampton\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Roehampton-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"London, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10231,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Bournemouth University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bournemouth University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Bournemouth-University-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/bournemouth/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Bournemouth University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Located on the south coast of England, Bournemouth University is situated in an area of outstanding natural beauty less than two hours from central London by train.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Located on the south coast of England, Bournemouth University is situated in an area of outstanding natural beauty less than two hours from central London by train.","address":"Fern Barrow, Poole BH12 5BB, UK","location":{"lat":"50.7435102","state":"England","country":"United Kingdom","lng":"-1.8983382","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/bournemouth/","zoom":5,"extra_fields":{"post_excerpt":"Located on the south coast of England, Bournemouth University is situated in an area of outstanding natural beauty less than two hours from central London by train.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/c.png\" alt=\"Bournemouth University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/c-1.png\" alt=\"Bournemouth University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/c-2.png\" alt=\"Bournemouth University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/c-3.png\" alt=\"Bournemouth University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/c-4.png\" alt=\"Bournemouth University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/c-5.png\" alt=\"Bournemouth University\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact Bournemouth University\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> Talbot Campus, Fern Barrow, Poole, BH12 5BB, United Kingdom</p><p><strong>Website:</strong> <a href=\"https://www.bournemouth.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://bournemouth.ac.uk/</a></p><h3>Overview</h3><p>Located on the south coast of England, Bournemouth University is situated in an area of outstanding natural beauty less than two hours from central London by train. We are a green, safe and friendly town welcoming students from many countries.</p><p>\u00a0</p><p>Famous for its seven-mile stretch of award-winning sandy beaches, the town is also a thriving hub for a number of industries including the creative, financial and tourism sectors. The New Forest National Park is on our doorstep and the Jurassic Coast (which is a World Heritage site) is just a short drive away.</p><p>All our undergraduate degrees and many postgraduate degrees offer the opportunity to undertake a 30-week work placement to enhance your employability skills, gain industry experience and build a network that will be invaluable once you have graduated. Many of our postgraduate courses also offer both September or January offering you more flexibility.</p><p>\u00a0</p><p>Our Business School is accredited by the Association to Advance Collegiate Schools of Business (AACSB), an accreditation attained by fewer than 5% of business schools worldwide, placing Bournemouth University firmly amongst the top institutions globally for business degrees.</p><p>\u00a0</p><p>BU\u2019s Archaeology and Anthropology courses are among the first degree programmes in the UK to receive accreditation from the Chartered Institute for Archaeologists (CIfA) and University Archaeology UK. The accreditation scheme is a joint initiative to recognise undergraduate and Master\u2019s degrees providing skills relevant to a career in the historic environment.</p><p>\u00a0</p><p>At Bournemouth University we are also very proud to have the world's only National Centre for Computer Animation (NCCA), Queen\u2019s Anniversary winners and produce graduates who go on to fulfil their ambition of working within the games and animation industry.</p><p>\u00a0</p><p><strong>Population: </strong>19,000</p><p><strong>Campus Type: </strong>Suburban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li><p>Our animation alumni have gone on to work on films with Disney, Pixar, Universal Studios plus many more and have even won Oscars for their work</p></li><li><p>Bournemouth University is Ranked in the top 70 Young Universities in the World (Times Higher Education Young University Ranking 2022)</p></li><li><p>Our MBA programme gives you complimentary student membership Chartered Institute of Marketing (CIM).</p></li><li><p>In recent years we have invested more than \u00a3200 million in our buildings, IT and facilities.</p></li><li><p>Over 4,400 students were awarded bursaries or scholarships in 2021/22, worth over 3.5 million (undergraduate and postgraduate awards)</p></li><li><p>Bournemouth University has been delivering archaeology degrees for over 50 years, which demonstrates our commitment and contribution to this subject. The Department has world-class teaching and research facilities, equipment and collections.</p></li><li><p>We regularly host international conferences and are situated close to some of Britain\u2019s most iconic archaeological sites and historic landscapes, including the rich coastal heritage of the Jurassic Coast, a designated World Heritage Site</p></li><li><p>If you\u2019re a high-performing athlete and on a regional, national or international sports programme, you can apply for one of our sports scholarships \u2013 designed to provide you with the funding to take your sporting abilities to the next level.</p></li><li><p>Bournemouth University is 10th in the world for Hospitality and Leisure Management in the latest QS World University Rankings.</p></li><li><p>Number 1 in the UK by The Rookies for Visual Effects in their 2022 Best Visual Effects Schools.</p></li></ul>\t\t\n\t\t<h3>Videos</h3>https://youtu.be/E5_nQLQR1FAhttps://youtu.be/B82oO-XtDychttps://youtu.be/3FCrdwt2nTY\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p>You can apply to study a Bachelor\u2019s degree from year one if you hold a High School Graduation Diploma with a minimum GPA of 3.0 out of 4.0, plus at least one of the following:</p><p>\u00a0</p><ul data-rte-list=\"default\"><li><p>SAT tests are accepted only on courses which <strong>does not</strong> list required or relevant subjects. Minimum combined score varies between 1200 and 1300, according to the course applied for.</p></li><li><p>ACT tests are accepted only on courses which <strong>does not list</strong> required or relevant subjects. Minimum combined score varies between 24 and 26, according to the course applied for.</p></li><li><p>Advanced Placement tests - AP tests are required on courses which list required or relevant subjects. You will need 2 or 3 tests and the required score per subject will range between 3 and 5, depending on the course applied for. Additional tests such as SAT or ACT will support your application. If you apply for a course which requires AP tests but are unable to take the tests, please contact the International Admissions Team on iat@bournemouth.ac.uk to discuss your options.</p></li><li><p>Some courses will require an art portfolio and/or interview.</p></li></ul>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Accounting &amp; Finance BA (Hons)</li><li>Accounting BA (Hons)</li><li>Archaeology BA (Hons)</li><li>Archaeology and Anthropology BA (Hons)</li><li>Business &amp; Management (Economics) BA (Hons)</li><li>Business &amp; Management (Entrepreneurship) BA (Hons)</li><li>Business &amp; Management (Finance) BA (Hons)</li><li>Business &amp; Management (Global Operations) BA (Hons)</li><li>Business &amp; Management (HRM) BA (Hons)</li><li>Business &amp; Management (Marketing) BA (Hons)</li><li>Business &amp; Management (Project Management) BA (Hons)</li><li>Business &amp; Management (Retail Management) BA (Hons)</li><li>Business &amp; Management BA (Hons)</li><li>Commercial Photography BA (Hons)</li><li>Communication and Media BA (Hons)</li><li>Computer Animation Art &amp; Design BA (Hons)</li><li>Computer Animation Technical Arts BA (Hons)</li><li>Criminology BA (Hons)</li><li>Criminology with Law BA (Hons)</li><li>English BA (Hons)</li><li>Events Management BA (Hons)</li><li>Film BA (Hons)</li><li>Film Production and Cinematography BA (Hons)</li><li>Finance BA (Hons)</li><li>History BA (Hons)</li><li>Immersive Media BA (Hons)</li><li>International Business &amp; Management BA (Hons)</li><li>International Finance BA (Hons)</li><li>International Hospitality &amp; Tourism Management BA (Hons)</li><li>International Tourism &amp; Hospitality Management BA (Hons)</li><li>Marketing Communications BA (Hons)</li><li>Marketing Communications BA (Hons)</li><li>Marketing Communications with Advertising BA (Hons)</li><li>Marketing Communications with Advertising BA (Hons)</li><li>Marketing Communications with Digital Media BA (Hons)</li><li>Marketing Communications with Digital Media BA (Hons)</li><li>Marketing Communications with Public Relations BA (Hons)</li><li>Marketing Communications with Public Relations BA (Hons)</li><li>Media Production BA (Hons)</li><li>Multimedia Journalism BA (Hons)</li><li>Multimedia Sports Journalism BA (Hons)</li><li>Music and Sound Production BA (Hons)</li><li>Photography BA (Hons)</li><li>Politics &amp; Economics BA (Hons)</li><li>Politics &amp; Economics BA (Hons)</li><li>Politics BA (Hons)</li><li>Product Design BA (Hons)</li><li>Social Work BA (Hons)</li><li>Sociology BA (Hons)</li><li>Sociology &amp; Criminology BA (Hons)</li><li>Sociology &amp; Social Anthropology BA (Hons)</li><li>Television Production BA (Hons)</li><li>Tourism Management BA (Hons)</li><li>Visual Effects BA (Hons)</li><li>Engineering BEng (Hons)</li><li>Mechanical Engineering BEng (Hons)</li><li>Adult Nursing BSc (Hons)</li><li>Anthropology BSc (Hons)</li><li>Anthropology BSc (Hons)</li><li>Archaeological, Anthropological and Forensic Sciences BSc (Hons)</li><li>Archaeology BSc (Hons)</li></ul><ul id=\"majors\"><li>Biological Sciences BSc (Hons)</li><li>Biomedical Science BSc (Hons)</li><li>Business Computing with Analytics BSc (Hons)</li><li>Children&#8217;s and Young People&#8217;s Nursing BSc (Hons)</li><li>Computer Science BSc (Hons)</li><li>Computing BSc (Hons)</li><li>Cyber Security Management BSc (Hons)</li><li>Cyber Security with Digital Forensics BSc (Hons)</li><li>Cyberpsychology BSc (Hons)</li><li>Data Science and Artificial Intelligence BSc (Hons)</li><li>Design Engineering BSc (Hons)</li><li>Ecology &amp; Wildlife Conservation BSc (Hons)</li><li>Economics BSc (Hons)</li><li>Environmental Science BSc (Hons)</li><li>Forensic Biology BSc (Hons)</li><li>Forensic Investigation BSc (Hons)</li><li>Forensic Science BSc (Hons)</li><li>Games Design BSc (Hons)</li><li>Games Software Engineering BSc (Hons)</li><li>Geography BSc (Hons)</li><li>Information Technology Management BSc (Hons)</li><li>Marketing BSc (Hons)</li><li>Medical Science BSc (Hons)</li><li>Mental Health Nursing BSc (Hons)</li><li>Mental Health Nursing BSc (Hons)</li><li>Midwifery BSc (Hons)</li><li>Networks and Cyber Security BSc (Hons)</li><li>Nutrition BSc (Hons)</li><li>Occupational Therapy BSc (Hons)</li><li>Operating Department Practice BSc (Hons)</li><li>Paramedic Science BSc (Hons)</li><li>Physiotherapy BSc (Hons)</li><li>Product Design BSc (Hons)</li><li>Psychology BSc (Hons)</li><li>Psychology with Counselling BSc (Hons)</li><li>Psychology with Forensic Investigation BSc (Hons)</li><li>Software Engineering BSc (Hons)</li><li>Sport &amp; Exercise Science BSc (Hons)</li><li>Sport Coaching BSc (Hons)</li><li>Sport Management BSc (Hons)</li><li>Sports Therapy BSc (Hons)</li><li>Sports Therapy BSc (Hons)</li><li>Virtual and Augmented Reality BSc (Hons)</li><li>Law LLB (Hons)</li><li>Law with Politics LLB (Hons)</li><li>Law, Media &amp; Creative Industries LLB (Hons)</li><li>Product Design MDes (Hons)</li><li>Engineering MEng (Hons)</li><li>Mechanical Engineering MEng (Hons)</li></ul>\n\t\t\t<a href=\"https://www.bournemouth.ac.uk/study/undergraduate/courses\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>You will need to have successfully completed a US Bachelor\u2019s (Honours) degree in a relevant subject to be considered for a taught postgraduate degree at BU.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>3D Computer Animation MA</li><li>Adult Nursing MSc</li><li>Advanced Practice MA</li><li>Advertising MA</li><li>Artificial Intelligence for Media MSc</li><li>Artificial Intelligence for Media MSc</li><li>Bioarchaeology MSc</li><li>Biodiversity Conservation MSc</li><li>Cinematography for Film and Television MA</li><li>Cinematography for Film and Television MA</li><li>Clinical and Developmental Neuropsychology MSc</li><li>Cognitive Neuroscience MSc</li><li>Computer Animation and Visual Effects MSc</li><li>Corporate Governance MSc</li><li>Creative Writing and Publishing MA</li><li>Creative Writing and Publishing MA</li><li>Cyber Security &amp; Human Factors MSc</li><li>Data Science and Artificial Intelligence MSc</li><li>Digital Effects MA</li><li>Digital Health &amp; Artificial Intelligence MSc</li><li>Digital Health MSc</li><li>Directing Film and Television MA</li><li>Directing Film and Television MA</li><li>Disaster Management MSc</li><li>Engineering Project Management MSc</li><li>English and Literary Media MA</li><li>English and Literary Media MA</li><li>Events Management MSc</li><li>Film and Television MA</li><li>Finance MSc</li><li>Foundations of Clinical Psychology MSc</li><li>Green Economy MSc</li><li>Health Psychology MSc</li><li>Information Technology MSc</li><li>Innovation Management &amp; Entrepreneurship MSc</li><li>Intellectual Property LLM</li><li>International Accounting &amp; Finance MSc</li><li>International Commercial Law LLM</li><li>International Finance &amp; Economics MSc</li><li>International Hospitality &amp; Tourism Management MSc</li><li>International Management MSc</li><li>International Political Communication MA</li><li>International Political Communication MA</li><li>International Tax Law LLM</li><li>Internet of Things MSc</li><li>Internet of Things with Cyber Security MSc</li><li>Internet of Things with Data Analytics MSc</li><li>Investigative Forensic Psychology MSc</li></ul><ul id=\"majors\"><li>Leading &amp; Developing Services MA</li><li>Legal Practice LLM</li><li>Management with Business Analytics MSc</li><li>Management with Human Resources MSc</li><li>Marketing &amp; User Experience MSc</li><li>Marketing Communications MA</li><li>Marketing Communications MA</li><li>Marketing Management (Digital) MSc</li><li>Marketing Management (Retail) MSc</li><li>Marketing Management MSc</li><li>Marketing Management MSc</li><li>Mechanical Engineering Design MSc</li><li>Media &amp; Communication MA</li><li>Media &amp; Communication MA</li><li>Medical Imaging with Management MSc</li><li>Mental Health Nursing MSc</li><li>Multimedia Journalism MA</li><li>Multimedia Journalism MA</li><li>Nutrition &amp; Behaviour MSc</li><li>Physician Associate Studies MSc</li><li>Political Psychology MA</li><li>Political Psychology MA</li><li>Political Psychology MA</li><li>Post Production Editing MA</li><li>Producing Film and Television MA</li><li>Production Management MA</li><li>Psychology MSc</li><li>Public Health MSc</li><li>Public International Law LLM</li><li>Scriptwriting MA</li><li>Scriptwriting MA</li><li>Social Work MA</li><li>Sound Design for Screen MA</li><li>Sound Design for Screen MA</li><li>Sport Management MSc</li><li>Sport Management MSc</li><li>Sustainable Economic Development &amp; Emerging Markets MSc</li><li>ter of Business Administration Mas</li><li>Tourism Management MSc</li><li>Tourism Marketing Management MSc</li></ul>\n\t\t\t<a href=\"https://www.bournemouth.ac.uk/study/postgraduate\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"https://www.facebook.com/bournemouthuniversityinternational/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://twitter.com/bournemouthuni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.instagram.com/buinternational/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.youtube.com/user/bournemouthuni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.bournemouth.ac.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.bournemouth.ac.uk/study/international/bu-your-country/welcoming-students-united-states-america\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.bournemouth.ac.uk/study/international/international-fees-scholarship-information\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.bournemouth.ac.uk/scholarships\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.bournemouth.ac.uk/study/international/bu-your-country/united-states-america/funding-support-us-students\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.bournemouth.ac.uk/study/international/meet-us/webinars-virtual-events-international-students\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.bournemouth.ac.uk/research\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.bournemouth.ac.uk/why-bu/accommodation\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.bournemouth.ac.uk/why-bu/employability\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.bournemouth.ac.uk/why-bu/clubs-societies\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"https://www.bournemouth.ac.uk/study/undergraduate/how-apply\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"Bournemouth University","post_link":"https://theukstudyexpert.com/universities/bournemouth/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bournemouth University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Bournemouth-University-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"Poole, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10229,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Leeds Arts University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Leeds Arts University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Leeds-Arts-University-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/leeds-arts/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Leeds Arts University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                The only specialist arts university in the North of England, we are small and friendly, with a wide range of internationally recognised Foundation, Undergraduate and Postgraduate courses.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"The only specialist arts university in the North of England, we are small and friendly, with a wide range of internationally recognised Foundation, Undergraduate and Postgraduate courses.","address":"Blenheim Walk, Woodhouse, Leeds LS2 9AQ, UK","location":{"lat":"53.80884500000001","state":"England","country":"United Kingdom","lng":"-1.551577","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/leeds-arts/","zoom":5,"extra_fields":{"post_excerpt":"The only specialist arts university in the North of England, we are small and friendly, with a wide range of internationally recognised Foundation, Undergraduate and Postgraduate courses.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/d-7.png\" alt=\"Leeds Arts University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/d-1-1.png\" alt=\"Leeds Arts University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/d-2-1.png\" alt=\"Leeds Arts University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/d-3-1.png\" alt=\"Leeds Arts University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/d-4-1.png\" alt=\"Leeds Arts University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/d-6-1.png\" alt=\"Leeds Arts University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/d-5-1.png\" alt=\"Leeds Arts University\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact Leeds Arts University\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> Blenheim Walk, Leeds, LS2 9AQ, United Kingdom</p><p><strong>Website:</strong> <a href=\"https://www.leeds-art.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://leeds-art.ac.uk/</a></p><h3>Overview</h3><p>Over the last 170 years, we\u2019ve built an international reputation for delivering the highest quality arts education. The only specialist arts university in the North of England, we are small and friendly, with a wide range of internationally recognised Foundation, Undergraduate and Postgraduate courses.</p><p>\u00a0</p><p>91% of our students reported that they were satisfied overall with their course, ranking us higher in student satisfaction than all other UK specialist arts universities! We are proud to have won both the WhatUni Student Choice Award for Best Facilities and the WhatUni Student Choice Award for Student Support on multiple occasions.\u00a0In 2024, we were also nominated for the WhatUni Student Choice Award for best small or specialist university.</p><p>\u00a0</p><p>We have an outstanding reputation for consistently producing artists and designers of national and international repute \u2013 alumni include Henry Moore, Barbara Hepworth, Marcus Harvey, Damien Hirst, Danny Sangra and Omar Kashoura.</p><p>\u00a0</p><p>Our students benefit from small class sizes, expert staff, award-winning facilities and a creative atmosphere where anything feels possible. This is what makes Leeds Arts University the very best place to begin your creative journey!</p><p>\u00a0</p><p><strong>Population: </strong>2,500</p><p><strong>Campus Type: </strong>Urban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li><p>Leeds Arts University has been at the forefront of art and design education for over 170 years!</p></li><li><p>We have won the WhatUni Award for UK University with the Best Facilities multiple times!</p></li><li><p>We are the winners of the WhatUni Student Choice Award for Student Support!</p></li><li><p>We are the highest-ranked specialist arts university for student satisfaction!</p></li><li>Leeds has been voted the UK\u2019s Best Student City!</li><li>Adi Granov, Iron Man comic book artist, has an honorary degree from Leeds Arts University and has visited us to share his knowledge with our students</li><li>Outside of London, Leeds offers the country's best paying jobs!</li><li><p>Leeds has been voted the UK\u2019s Best Student City!</p></li></ul>\t\t\n\t\t<h3>Videos</h3>https://youtu.be/ZOu8s0suw7Uhttps://www.youtube.com/watch?v=iqkX0v5GXmUhttps://youtu.be/fBd-ZbWZ3QQ\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p>Foundation Diploma: <br /></p><p style=\"font-weight: 400;\">At enrolment you should normally have achieved the following:</p><ul><li style=\"font-weight: 400;\">Successful completion of the USA High School Diploma with an overall GPA of 2.8</li></ul><p style=\"font-weight: 400;\">\u00a0</p><p style=\"font-weight: 400;\">You will also need:</p><ul><li style=\"font-weight: 400;\">A reference to support your application from an academic teacher, tutor, or counsellor</li><li style=\"font-weight: 400;\">Examples of work or audition to demonstrate your interest and ability in art, design, and/or technology.\u201d</li></ul><p><br /><br />Undergraduate Degree: </p><p><br />Successful completion of the USA High School Graduation Diploma with a minimum GPA of 3.0</p><p>Plus one of:<br /><br /></p><ul data-rte-list=\"default\"><li><p>ACT test results with minimum scores of 24</p></li><li><p>2 AP exam results with a grade of 3 or higher</p></li><li><p>SAT I (Reasoning) scores of at least 1100</p></li></ul><p>An overall higher GPA in your High School Graduation Diploma may exempt you from any additional requirements. We will consider each application on a case-by-case basis, adopting a flexible and inclusive approach to students who have been unable to access standardised tests. We will consider honours classes, IB courses, or university/community college credit-bearing courses in lieu.<br /><br /></p><p>You will also need:<br /><br /></p><ul data-rte-list=\"default\"><li><p>Examples of work or audition</p></li><li><p>One reference to support your application from an academic teacher, tutor, or counsellor</p></li></ul><p><br />Advanced entry to the second year of an Undergraduate degree is possible for students with an Associate Degree (minimum GPA of 3.0 overall) depending on subject match.</p><p>Please feel free to contact us through the contact button to discuss your application if you have any questions.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li style=\"list-style-type: none;\"><ul><li>BA Acting for Screen</li><li>BA Animation</li><li>BA Comic and Concept Art</li><li>BA Creative Writing</li><li>BA Fashion Design</li><li>BA Fashion Marketing</li><li>BA Fashion Photography</li><li>BA Filmmaking</li><li>BA Fine Art</li><li>BA Games Art</li><li>BA Games Design</li><li>BA Graphic Design</li><li>BA Illustration</li><li>BA Marketing Communications</li><li>BA Music Production</li><li>BA Photography</li><li>BA Popular Music Performance</li><li>BA Textile Design</li><li>BA Visual Communication</li></ul></li></ul>\n\t\t\t<a href=\"http://www.leeds-art.ac.uk/study/undergraduate-courses/\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>A 2:2 undergraduate UK honours degree (equivalent to a CGPA 2.7+) or international equivalent or; A degree-equivalent postgraduate diploma /professional qualification.</p><p>\u00a0</p><p>You will also need:</p><p>\u00a0</p><p>\u00a0</p><ul><li>Examples of work</li><li>One reference to support your application from an academic or a creative practitioner</li></ul><p>\u00a0</p><p>Applicants who hold a degree from another discipline or have experiential learning in lieu of a degree that can demonstrate appropriate knowledge and skills may also be considered for entry.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li style=\"list-style-type: none;\"><ul><li>MA Animation</li><li>MA Creative Practice</li><li>MA Digital Fashion</li><li>MA Fine Art</li></ul></li></ul><ul id=\"majors\"><li style=\"list-style-type: none;\"><ul><li>MA Graphic Design</li><li>MA Illustration with Graphic Novel</li><li>MA Photography</li></ul></li></ul>\n\t\t\t<a href=\"http://www.leeds-art.ac.uk/study/postgraduate-courses/\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"http://www.facebook.com/LeedsArtsUni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://twitter.com/LeedsArtsUni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.instagram.com/leedsartsuni/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.youtube.com/@leedscollegeofart\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.leeds-art.ac.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.leeds-art.ac.uk/international/information-for-international-students\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.leeds-art.ac.uk/international/information-for-international-students/usa\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.leeds-art.ac.uk/international/information-for-international-students\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.leeds-art.ac.uk/international/us-federal-aid\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.leeds-art.ac.uk/book-an-open-day\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.leeds-art.ac.uk/research\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.leeds-art.ac.uk/life-in-leeds\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.leeds-art.ac.uk/careers-industry\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.leedsartsunion.org.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"https://www.leeds-art.ac.uk/apply/\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"Leeds Arts University","post_link":"https://theukstudyexpert.com/universities/leeds-arts/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Leeds Arts University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Leeds-Arts-University-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.4-2.59, 2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Creativeperforming Arts Design, England","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"2.4-2.59, 2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Creativeperforming Arts Design, England","city_country":"Leeds, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10227,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Aberystwyth University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Aberystwyth University Logo\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Aberystwyth-University-Logo-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/aberystwyth-university/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Aberystwyth University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Established in 1872, as the first University College in Wales, Aberystwyth University is one of the UK\u2019s most important institutions.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Established in 1872, as the first University College in Wales, Aberystwyth University is one of the UK\u2019s most important institutions.","address":"10 Laura Pl, Aberystwyth SY23 3FL, UK","location":{"lat":"52.4140902","state":"Wales","country":"United Kingdom","lng":"-4.0875488","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/aberystwyth-university/","zoom":5,"extra_fields":{"post_excerpt":"Established in 1872, as the first University College in Wales, Aberystwyth University is one of the UK\u2019s most important institutions.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/985-IEC-Town_and_Prom_PAU0669_59727.jpg\" alt=\"Aberystwyth University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/862-recruitment-VSJ_8806_58641.jpg\" alt=\"Aberystwyth University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Cmpus_students-090818_PAU5392_62265.jpg\" alt=\"Aberystwyth University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Cmpus_students-090818_PAU4738_62206.jpg\" alt=\"Aberystwyth University\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/950-Football-_AU_1556_55859.jpg\" alt=\"Aberystwyth University\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact Aberystwyth University\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> Aberystwyth University Penglais Campus, Aberystwyth, Ceredigion, SY23 3FL</p><p><strong>Website:</strong> <a href=\"https://aber.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://aber.ac.uk/</a></p><h3>Overview</h3><p>Established in 1872, as the first University College in Wales, Aberystwyth University is one of the UK\u2019s most important institutions. Our reputation for research power, teaching excellence, graduate employability and our unbelievable location are what set us apart from other universities.</p><p>\u00a0</p><p>We pride ourselves on being ranked #1 in the UK for Teaching Quality*. Our teaching is directly informed by cutting-edge research; includes a strong focus on developing professional skills; and our high staff-student ratio means every student has the support they need to succeed. 97% of our graduates are in employment or further study within 6 months, and Student Satisfaction is higher than at any other UK University**.</p><p>\u00a0</p><p>Aberystwyth is a vibrant and welcoming university town in a stunning location on the west coast of the UK. It is both at the heart of Wales and home to a rich variety of cultures, people and entertainment. It is home to the impressive National Library of Wales: one of few places to contain a copy of every book ever printed in the UK.</p><p>\u00a0</p><p>For international students, we offer generous Scholarships covering the cost of your accommodation, as well as free gym membership, immigration advice, careers support and transport to Aberystwyth upon arrival to the UK.</p><p>\u00a0</p><p>With the mountains behind you and the sea at your toes, you will not find a more beautiful place than Aberystwyth University to learn new concepts, develop friendships, broaden your horizons and kick-start your career.</p><p>\u00a0</p><p>*The Times: Good University Guide 2021</p><p>** The Times: Good University Guide 2021</p><p>\u00a0</p><p><strong>Population: </strong>6,805</p><p><strong>Campus Type: </strong>Rural</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li><p>Top University of Student Satisfaction (The Times, Good University Guide 2021)</p></li><li><p>Top University for Teaching Quality (The Times, Good University Guide 2021)</p></li><li><p>Amazing scenery with the coast and mountains giving plenty of outdoor opportunities.</p></li><li><p>The National Library of Wales is right on our doorstep.</p></li></ul>\t\t\n\t\t<h3>Videos</h3>https://youtu.be/N2qemINsv3ghttps://youtu.be/S-YbzRtyRxAhttps://youtu.be/Gr6_ar2Boac\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p>Minimum final GPA of 3.0 - 3.2 (depending on the subject to be studied)</p><p><strong>Plus one of the following:</strong></p><ul><li><p>Minimum of 2 AP tests with scores of 3+ (subject-specific requirements for some degree programmes)</p></li><li><p>Minimum of 2 High School Honors classes with B grades</p></li><li><p>Minimum of 2 College Level classes with B grades</p></li></ul><p>\u00a0</p><p>Applicants with lower scores may be considered for courses with integrated foundation years.</p><p>\u00a0</p><p>For mature learners (ie applicants over the age of 21), we will also consider work experience in lieu of exams on a case by case basis.</p><p>\u00a0</p><p>If you are studying the IB programme we generally look for 26-30 points.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Accounting And Finance</li><li>Adventure Tourism Management</li><li>Agriculture</li><li>Animal Behaviour</li><li>Animal Science</li><li>Applied Mathematics / Pure Mathematics</li><li>Art</li><li>Art History</li><li>Artificial Intelligence And Robotics</li><li>Astrophysics</li><li>Biochemistry</li><li>Biological Sciences</li><li>Biology</li><li>Biology And Climate Change</li><li>Biomedical Sciences</li><li>Business And Climate Change</li><li>Business And Management</li><li>Business Economics</li><li>Business Finance</li><li>Business Information Technology</li><li>Business Law</li><li>Celtic Studies</li><li>Childhood Studies</li><li>Computer Graphics Vision And Games</li><li>Computer Science</li><li>Countryside Conservation</li><li>Creative Arts</li><li>Creative Writing</li><li>Criminal Law</li><li>Criminology</li><li>Cultural Heritage: Libraries, Archives and Museums</li><li>Cymraeg</li><li>Data Science</li><li>Digital Marketing</li><li>Drama And Theatre</li><li>Early Childhood Studies With Early Years Practitioner Status</li><li>Ecology</li><li>Economics</li><li>Education</li><li>Engineering Physics</li><li>English</li><li>English And Creative Writing</li><li>English Literature</li><li>Environmental Earth Science</li><li>Environmental Science</li><li>Equine And Veterinary Bioscience</li><li>Equine Science</li><li>Equine Studies</li><li>European Languages</li><li>European Law</li><li>Film And Television Studies</li></ul><ul id=\"majors\"><li>Film-Making</li><li>Financial Mathematics</li><li>Fine Art</li><li>French</li><li>Genetics</li><li>Geography</li><li>History</li><li>History And Media</li><li>History And Welsh History</li><li>Human Biology And Health</li><li>Human Geography</li><li>Human Rights</li><li>Information And Library Studies</li><li>International Politics</li><li>Internet Computing And Systems Administration</li><li>Law</li><li>Liberal Arts</li><li>Life Sciences</li><li>Marine And Freshwater Biology</li><li>Marketing</li><li>Mathematical And Physical Sciences</li><li>Mathematical And Theoretical Physics</li><li>Mathematics</li><li>Media And Communication Studies</li><li>Medieval And Early Modern History</li><li>Microbiology</li><li>Modern And Contemporary History</li><li>Modern German Studies</li><li>Modern Languages</li><li>Physical Geography</li><li>Physics</li><li>Plant Biology</li><li>Plant Biology With Foundation Year</li><li>Political Studies</li><li>Politics</li><li>Politics And Modern History</li><li>Psychology</li><li>Pure Mathematics / Statistics</li><li>Robotics And Embedded Systems Engineering</li><li>Scenography And Theatre Design</li><li>Sociology</li><li>Software Engineering</li><li>Space Science And Robotics</li><li>Sport And Exercise Science</li><li>Strategy Intelligence And Security</li><li>Theatre Film And Television</li><li>Tourism Management</li><li>Veterinary Biosciences</li><li>Web Development</li><li>Wildlife Conservation</li><li>Writing For Broadcasting Media And Performance</li><li>Zoology</li></ul>\n\t\t\t<a href=\"https://www.aber.ac.uk/en/undergrad/\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>Generally, the minimum entry requirement for most taught Masters courses is a lower second class honours degree (2ii). However, some departments may require upper second class honours degrees (2i) (e.g. School of Art) or relevant work experience.</p><p>\u00a0</p><p>2.6 GPA = UK 2ii Honours</p><p>3.1 GPA = UK 2i Honours</p><p>3.6 GPA = UK 1st Class Honours</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Accounting</li><li>Advanced Computer Science</li><li>Advanced Media Production</li><li>Agriculture</li><li>Agrifood Innovation</li><li>Animal Science</li><li>Archive Administration</li><li>Archives And Records Management</li><li>Art</li><li>Art History</li><li>Artificial Intelligence</li><li>Bioinnovation</li><li>Biological Sciences</li><li>Biology With Balanced Science</li><li>Biosciences</li><li>Biotechnology</li><li>Business Administration</li><li>Change Leadership</li><li>Chemistry With Balanced Science</li><li>Computer Science</li><li>Creative Writing</li><li>Criminology</li><li>Criminology And Criminal Justice</li><li>Data Science</li><li>Digital Curation</li><li>Digital Information And Media Management</li><li>Digital Preservation</li><li>Documentary Filmmaking: Landscape And Ecology</li><li>Drama</li><li>Economics</li><li>Education</li><li>English</li><li>Environmental Change Impact And Adaptation</li><li>Environmental Law And Human Rights</li><li>Environmental Law And Management</li><li>Environmental Management</li><li>Equine Science</li><li>European Languages</li><li>Farm Consultancy And Knowledge Exchange</li><li>Film Producing</li><li>Finance</li><li>Fine Art</li></ul><ul id=\"majors\"><li>Geography</li><li>Geography And Earth Sciences</li><li>History</li><li>History And Heritage</li><li>History Of Wales</li><li>Human Rights And Humanitarian Law</li><li>Industrial Biotechnology</li><li>Information And Library Studies</li><li>Information Governance And Assurance</li><li>International Archives Records And Information Management</li><li>International Business And Marketing</li><li>International Business Management</li><li>International Commercial And Environmental Law</li><li>International Commercial Law</li><li>International Finance</li><li>International Politics</li><li>International Relations</li><li>Law</li><li>Librarianship</li><li>Literary Studies</li><li>Literature And Creative Writing</li><li>Livestock Science</li><li>Management</li><li>Master Of Business Administration</li><li>Mathematics</li><li>Medieval Britain &amp; Europe</li><li>Modern History</li><li>Modern Languages</li><li>Parasite Control</li><li>Physics</li><li>Professional Doctorate In Agriculture</li><li>Psychology</li><li>Remote Sensing And Gis</li><li>Sport And Exercise Science</li><li>Statistics For Computational Biology</li><li>Sustainable And Efficient Food Production</li><li>Theatre Film &amp; TV Studies</li><li>Teaching In Higher Educations</li><li>Theatre Practice: Performance And Scenography</li><li>Welsh And Celtic Studies</li><li>Youth Justice</li></ul>\n\t\t\t<a href=\"https://www.aber.ac.uk/en/postgrad/taught-programmes/#:~:text=Taught%20programmes%20include%20Masters%20of,Master%20of%20Research%20(MRes)%3B\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"http://www.facebook.com/aberinternational\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.facebook.com/aberinternational\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.instagram.com/aberinternational\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.youtube.com/channel/UCDREnifYDet3lKw6eDOB9uQ\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.aber.ac.uk/en/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.aber.ac.uk/en/study-with-us/international/countries/welcome-usa/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.aber.ac.uk/en/study-with-us/international/fees-scholarships/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.aber.ac.uk/en/study-with-us/international/fees-scholarships/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.aber.ac.uk/en/study-with-us/fees/postgrad/international/us-federal-loans/name-217507-en.html\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://virtual-tour.aber.ac.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.aber.ac.uk/en/rbi/research/aber-research/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.aber.ac.uk/en/accommodation/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.aber.ac.uk/en/studentservices/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.abersu.co.uk/teamaber/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"https://www.aber.ac.uk/en/undergrad/apply-now/?from=globalnav\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"Aberystwyth University","post_link":"https://theukstudyexpert.com/universities/aberystwyth-university/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Aberystwyth University Logo\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Aberystwyth-University-Logo-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Humanities, Life Physical Sciences, Social Science, Technology Computer Science, Wales","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Humanities, Life Physical Sciences, Social Science, Technology Computer Science, Wales","city_country":"Aberystwyth, Wales"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10225,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Middlesex University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Middlesex University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Middlesex-University-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/middlesex/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Middlesex University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Middlesex University is a world-class centre for education, research and skills-based learning with a 130 year heritage. Our degrees focus on employability.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Middlesex University is a world-class centre for education, research and skills-based learning with a 130 year heritage. Our degrees focus on employability.","address":"The Burroughs, London NW4 4BT, UK","location":{"lat":"51.5897112","state":"England","country":"United Kingdom","lng":"-0.2293488","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/middlesex/","zoom":5,"extra_fields":{"post_excerpt":"Middlesex University is a world-class centre for education, research and skills-based learning with a 130 year heritage. Our degrees focus on employability.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Zoom-PGstudentonQuad.jpg\" alt=\"Middlesex University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/middle.png\" alt=\"Middlesex University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/009-Law.jpg\" alt=\"Middlesex University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/handsonlearningscience01.jpg\" alt=\"Middlesex University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Zoombanner-Quad.jpg\" alt=\"Middlesex University\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact Middlesex University London\r\n</a>\r\n\r\n<strong>Location:</strong> The Burroughs, London United Kingdom NW4 4BT\r\n\r\n<strong>Website:</strong> <a href=\"https://www.mdx.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://mdx.ac.uk/</a>\r\n<h3>Overview</h3>\r\nMiddlesex University is a world-class centre for education, research and skills-based learning with a 130 year heritage. We offer a wide range of courses, taught by academics who are researchers or practitioners in their field and share their real life experience with their students.\r\n\r\nOur state-of-the-art campus in Hendon, north London, is one of the biggest in the capital and means our students have everything they need in one place \u2013 including 24/7 support.\r\n\r\nOur students come from all corners of the globe; a third from outside the UK \u2013 as do many of our academics. This creates a diverse learning environment that gives you the international perspective you need to compete in the global job market.\r\n\r\nMiddlesex University degrees focus on employability and encourage work placements, which is why we\u2019ve been ranked among the top UK universities for graduate salaries, meaning you\u2019ll be well placed to succeed in an increasingly competitive job market.\r\n\r\n<strong>Population: </strong>15,000\r\n\r\n<strong>Campus Type: </strong>Suburban\r\n<h3>Quick Facts</h3>\r\n<ul data-rte-list=\"default\">\r\n \t<li>Top 5 university in the UK (THE Young Universities 2023)</li>\r\n \t<li>5th in London for overall student positivity (NSS 2023)</li>\r\n \t<li>90% of research is recognized as internationally significant.</li>\r\n \t<li>Top 15th international universities in the world (Times Higher Education).</li>\r\n \t<li>Top 20 across all creative industries research disciplines.</li>\r\n \t<li>First university to receive a UKIED Gold award for equality and diversity -One of two UK universities to be awarded the highest 3-star Fairtrade University status</li>\r\n \t<li>Ranked #12 out of 776 institutions for SDG5 Gender Equality in The Times Higher Education Impact Rankings 2021.</li>\r\n \t<li>20 min into central London by tube</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://youtu.be/vSuLKO-J_mkhttps://youtu.be/YL5hxy1o1HEhttps://youtu.be/clh8pV7mWCAhttps://youtu.be/93BoKJVh2Fw\r\n<h3>Undergraduate Information</h3>\r\n<h3>US Entry Requirements</h3>\r\n<h5>GPA Requirement</h5>\r\n<strong>3.2+</strong>\r\n\r\nTest optional / not required.\u00a0Some programmes may require specific subject\u00a0requirements, which can be met with 2 AP exams\u00a0in the subject area. A minimum of 3-4 AP tests with\u00a0Grades of 5 (with specific subjects). Expected to be\u00a0taken alongside a relevant high school diploma.\r\n\r\n<strong>2.8 - 3.1</strong>\r\n\r\nSAT of 550 on each part, OR ACT composite score of 23, OR 2 AP exams with\u00a03+\r\n\r\n<strong>2.7 or below</strong>\r\n\r\nCan be considered for a Foundation Year.\u00a0Must provide SAT of 550 on each part, OR\u00a0ACT composite score of 23, OR 2 AP exams\u00a0with 3+\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n<ul id=\"majors\">\r\n \t<li>BA 3D Animation and Games</li>\r\n \t<li>BA 3D Animation and Games with Foundation Year</li>\r\n \t<li>BA Accounting and Finance</li>\r\n \t<li>BA Advertising, Public Relations and Branding</li>\r\n \t<li>BA Advertising, Public Relations and Branding with Foundation Year</li>\r\n \t<li>BA Animation</li>\r\n \t<li>BA Animation with Foundation Year</li>\r\n \t<li>BA Business Management</li>\r\n \t<li>BA Business Management</li>\r\n \t<li>BA Business Management (1 year Top-Up)</li>\r\n \t<li>BA Business Management (2 year Top-Up)</li>\r\n \t<li>BA Business Management (Fast Track)</li>\r\n \t<li>BA Business Management (Finance)</li>\r\n \t<li>BA Business Management (Finance) (1 year Top up)</li>\r\n \t<li>BA Business Management (Human Resource Management)</li>\r\n \t<li>BA Business Management (Innovation and Entrepreneurship)</li>\r\n \t<li>BA Business Management (Innovation and Entrepreneurship) (1 year Top up)</li>\r\n \t<li>BA Business Management (Marketing)</li>\r\n \t<li>BA Business Management (Marketing) (1 year Top up)</li>\r\n \t<li>BA Business Management (Project Management)</li>\r\n \t<li>BA Business Management (Project Management) (1 year Top up)</li>\r\n \t<li>BA Business Management (Supply Chain and Logistics)</li>\r\n \t<li>BA Business Management (Supply Chain and Logistics) (1 year Top up)</li>\r\n \t<li>BA Business Management (Supply Chain) (1 year Top up)</li>\r\n \t<li>BA Business Management with Foundation Year</li>\r\n \t<li>BA Business Management with Mandarin (4 year)</li>\r\n \t<li>BA Creative Writing and Journalism</li>\r\n \t<li>BA Creative Writing and Journalism with Foundation Year</li>\r\n \t<li>BA Criminology</li>\r\n \t<li>BA Criminology (Criminal Justice)</li>\r\n \t<li>BA Criminology (Policing and Investigations)</li>\r\n \t<li>BA Criminology (Policing and Investigations) with Foundation Year</li>\r\n \t<li>BA Criminology with Foundation Year</li>\r\n \t<li>BA Dance Performance</li>\r\n \t<li>BA Dance Practices</li>\r\n \t<li>BA Digital Media</li>\r\n \t<li>BA Digital Media with Foundation Year</li>\r\n \t<li>BA Early Childhood Studies</li>\r\n \t<li>BA Education Studies</li>\r\n \t<li>BA English</li>\r\n \t<li>BA English with Foundation Year</li>\r\n \t<li>BA Fashion Communication and Styling</li>\r\n \t<li>BA Fashion Communication and Styling with Foundation Year</li>\r\n \t<li>BA Fashion Design</li>\r\n \t<li>BA Fashion Design with Foundation Year</li>\r\n \t<li>BA Fashion Textiles and Design</li>\r\n \t<li>BA Fashion Textiles and Design with Foundation Year</li>\r\n \t<li>BA Film</li>\r\n \t<li>BA Film with Foundation Year</li>\r\n \t<li>BA Financial Services (1 year Top up)</li>\r\n \t<li>BA Fine Art</li>\r\n \t<li>BA Fine Art with Foundation Year</li>\r\n \t<li>BA Games Design</li>\r\n \t<li>BA Games Design with Foundation Year</li>\r\n \t<li>BA Graphic Design</li>\r\n \t<li>BA Graphic Design with Foundation Year</li>\r\n \t<li>BA Illustration</li>\r\n \t<li>BA Illustration with Foundation Year</li>\r\n \t<li>BA Interior Architecture</li>\r\n \t<li>BA Interior Architecture with Foundation Year</li>\r\n \t<li>BA Interior Design</li>\r\n \t<li>BA Interior Design with Foundation Year</li>\r\n \t<li>BA International Business</li>\r\n \t<li>BA International Business Administration (1 year Top Up)</li>\r\n \t<li>BA International Business Administration (2 year Top up)</li>\r\n \t<li>BA International Politics and Law</li>\r\n \t<li>BA International Politics and Law with Foundation Year</li>\r\n \t<li>BA International Politics, Economics and Law</li>\r\n \t<li>BA International Tourism Management with Mandarin</li>\r\n \t<li>BA Law</li>\r\n \t<li>BA Law with Foundation Year</li>\r\n \t<li>BA Marketing</li>\r\n \t<li>BA Marketing with Foundation Year</li>\r\n \t<li>BA Music</li>\r\n \t<li>BA Music Business and Arts Management</li>\r\n \t<li>BA Photography</li>\r\n \t<li>BA Photography with Foundation Year</li>\r\n \t<li>BA Primary Education (QTS)</li>\r\n \t<li>BA Product Design</li>\r\n \t<li>BA Professional Practice (Negotiated Specialism)</li>\r\n \t<li>BA Professional Practice in Management</li>\r\n \t<li>BA Professional Practice, Arts and Creative Industries (specialisation)</li>\r\n \t<li>BA Social Work</li>\r\n \t<li>BA Television and Digital Production</li>\r\n \t<li>BA Television and Digital Production with Foundation Year</li>\r\n \t<li>BA Theatre Design and Production</li>\r\n \t<li>BA Theatre Design and Production with Foundation Year</li>\r\n \t<li>BA Theatre Performance and Production</li>\r\n \t<li>BA Visual Effects</li>\r\n \t<li>BA Visual Effects with Foundation Year</li>\r\n \t<li>Bachelor of Laws (LLB)</li>\r\n \t<li>BEng Biomedical Engineering</li>\r\n \t<li>BEng Computer Systems Engineering</li>\r\n \t<li>BEng Computer Systems Engineering with Foundation Year</li>\r\n \t<li>BEng Design Engineering</li>\r\n \t<li>BEng Design Engineering with Foundation Year</li>\r\n \t<li>BEng Electronic Engineering</li>\r\n \t<li>BEng Electronic Engineering with Foundation Year</li>\r\n \t<li>BEng Mechatronics</li>\r\n \t<li>BEng Mechatronics with Foundation Year</li>\r\n \t<li>BEng Product Design Engineering</li>\r\n \t<li>BEng Robotics</li>\r\n \t<li>BEng Robotics with Foundation Year</li>\r\n \t<li>BSc (Hons) Mental Health Nursing (Professional Practice) (Top Up)</li>\r\n \t<li>BSc (Hons) Midwifery (Professional Practice) (Top Up)</li>\r\n \t<li>BSc Architectural Technology</li>\r\n \t<li>BSc Banking and Finance</li>\r\n</ul>\r\n<ul id=\"majors\">\r\n \t<li>BSc Banking and Finance with Foundation Year</li>\r\n \t<li>BSc Biochemistry</li>\r\n \t<li>BSc Biochemistry with Foundation Year</li>\r\n \t<li>BSc Biology</li>\r\n \t<li>BSc Biology with Foundation Year</li>\r\n \t<li>BSc Biomedical Science</li>\r\n \t<li>BSc Biomedical Science with Foundation Year</li>\r\n \t<li>BSc Business Accounting</li>\r\n \t<li>BSc Business Economics</li>\r\n \t<li>BSc Business Information Systems</li>\r\n \t<li>BSc Business Information Systems with Foundation Year</li>\r\n \t<li>BSc Computer Forensics</li>\r\n \t<li>BSc Computer Networks</li>\r\n \t<li>BSc Computer Networks and Security</li>\r\n \t<li>BSc Computer Networks and Security with Foundation Year</li>\r\n \t<li>BSc Computer Networks with Foundation Year</li>\r\n \t<li>BSc Computer Science</li>\r\n \t<li>BSc Computer Science (Systems Engineering)</li>\r\n \t<li>BSc Computer Science with Foundation Year</li>\r\n \t<li>BSc Cyber Security and Digital Forensics</li>\r\n \t<li>BSc Cyber Security and Digital Forensics with Foundation Year</li>\r\n \t<li>BSc Economics</li>\r\n \t<li>BSc Environmental Health with Foundation Year</li>\r\n \t<li>BSc Environmental Science</li>\r\n \t<li>BSc Environmental Science with Foundation Year</li>\r\n \t<li>BSc Games Design</li>\r\n \t<li>BSc Games Design with Foundation Year</li>\r\n \t<li>BSc Healthcare Science (Audiology) (Apprenticeship)</li>\r\n \t<li>BSc Healthcare Science (Cardiac Physiology)</li>\r\n \t<li>BSc Healthcare Science (Neurophysiology)</li>\r\n \t<li>BSc Information Systems (Top Up)</li>\r\n \t<li>BSc Information Technology</li>\r\n \t<li>BSc Information Technology and Business Information Systems(Top Up)</li>\r\n \t<li>BSc Information Technology with Foundation Year</li>\r\n \t<li>BSc International Hospitality and Tourism Management (1 year Top up)</li>\r\n \t<li>BSc International Tourism Management</li>\r\n \t<li>BSc International Tourism Management with Foundation Year</li>\r\n \t<li>BSc Mathematics</li>\r\n \t<li>BSc Mathematics and Data Science</li>\r\n \t<li>BSc Mathematics and Data Science with Foundation Year</li>\r\n \t<li>BSc Mathematics with Foundation Year</li>\r\n \t<li>BSc Medical Biochemistry with Foundation Year</li>\r\n \t<li>BSc Medical Physiology</li>\r\n \t<li>BSc Medical Physiology with Foundation Year</li>\r\n \t<li>BSc Medical Science</li>\r\n \t<li>BSc Medical Science with Foundation Year</li>\r\n \t<li>BSc Medical Science with Innovation and Enterprise</li>\r\n \t<li>BSc Midwifery</li>\r\n \t<li>BSc Neuroscience</li>\r\n \t<li>BSc Neuroscience with Foundation Year</li>\r\n \t<li>BSc Nursing (Adult)</li>\r\n \t<li>BSc Nursing (Child)</li>\r\n \t<li>BSc Nursing (Mental Health)</li>\r\n \t<li>BSc Nursing (Professional Practice) (Top Up)</li>\r\n \t<li>BSc Nutrition</li>\r\n \t<li>BSc Nutrition with Foundation Year</li>\r\n \t<li>BSc Occupational Safety and Health Management (Top Up)</li>\r\n \t<li>BSc Pharmaceutical Chemistry</li>\r\n \t<li>BSc Pharmaceutical Chemistry with Foundation Year</li>\r\n \t<li>BSc Professional Practice (Negotiated Specialism)</li>\r\n \t<li>BSc Psychology</li>\r\n \t<li>BSc Psychology with Counselling Skills</li>\r\n \t<li>BSc Psychology with Counselling Skills with Foundation Year</li>\r\n \t<li>BSc Psychology with Criminology</li>\r\n \t<li>BSc Psychology with Criminology with Foundation Year</li>\r\n \t<li>BSc Psychology with Education</li>\r\n \t<li>BSc Psychology with Education with Foundation Year</li>\r\n \t<li>BSc Psychology with Foundation Year</li>\r\n \t<li>BSc Psychology with Neuroscience</li>\r\n \t<li>BSc Psychology with Neuroscience with Foundation Year</li>\r\n \t<li>BSc Public Health</li>\r\n \t<li>BSc Public Health with Foundation Year</li>\r\n \t<li>BSc Sport and Exercise Science</li>\r\n \t<li>BSc Sport and Exercise Science (Football Science)</li>\r\n \t<li>BSc Sport and Exercise Science (Football Science) with Foundation Year</li>\r\n \t<li>BSc Sport and Exercise Science (Physical Education and Coaching)</li>\r\n \t<li>BSc Sport and Exercise Science (Physical Education and Coaching) with Foundation Year</li>\r\n \t<li>BSc Sport and Exercise Science (Strength and Conditioning)</li>\r\n \t<li>BSc Sport and Exercise Science (Strength and Conditioning) with Foundation Year</li>\r\n \t<li>BSc Sport and Exercise Science with Foundation Year</li>\r\n \t<li>BSc Sports and Exercise Rehabilitation</li>\r\n \t<li>BSc Veterinary Nursing (College of Animal Welfare \u2013 Huntingdon)</li>\r\n \t<li>BSc Veterinary Nursing (College of Animal Welfare \u2013 Huntingdon) (Top Up)</li>\r\n \t<li>BSc Veterinary Nursing (College of Animal Welfare \u2013 Leeds)</li>\r\n \t<li>BSc Veterinary Nursing (College of Animal Welfare \u2013 Leeds) (Top Up)</li>\r\n \t<li>BSc Veterinary Nursing (College of Animal Welfare)</li>\r\n \t<li>BSc Veterinary Nursing (College of Animal Welfare) (Top Up)</li>\r\n \t<li>BSc Veterinary Nursing with Foundation Year (College of Animal Welfare \u2013 Huntingdon)</li>\r\n \t<li>DipHE Biomedical Science</li>\r\n \t<li>Diploma Coaching Professional</li>\r\n \t<li>Diploma Coaching Professional Apprenticeship</li>\r\n \t<li>LLB Law with Criminology</li>\r\n \t<li>LLB Law with Human Rights</li>\r\n \t<li>LLB Law with International Relations</li>\r\n</ul>\r\n<a href=\"https://www.mdx.ac.uk/study-with-us/undergraduate\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nFor general admission onto most postgraduate courses, applicants need to have completed a bachelors degree from an accredited university or college with a Grade Point Average of 3.0 or higher.\r\n\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n<ul id=\"majors\">\r\n \t<li>Global Online Masters of Business Administration</li>\r\n \t<li>LLM</li>\r\n \t<li>LLM Commercial Law</li>\r\n \t<li>LLM Human Rights Law</li>\r\n \t<li>LLM International Minority Rights Law</li>\r\n \t<li>MA Advanced Professional Practice (Negotiated Specialism)</li>\r\n \t<li>MA Arts Management</li>\r\n \t<li>MA Arts Management</li>\r\n \t<li>MA by Research within the Faculty of Arts and Creative Industries</li>\r\n \t<li>MA by Research within the school of Media and Performing Arts</li>\r\n \t<li>MA Childhood and Education in Diverse Societies</li>\r\n \t<li>MA Childhood and Education in Diverse Societies (Distance Education)</li>\r\n \t<li>MA Children\u2019s Book Illustration and Graphic Novels</li>\r\n \t<li>MA Children\u2019s Book Illustration and Graphic Novels</li>\r\n \t<li>MA Classical Music Business</li>\r\n \t<li>MA Classical Music Business</li>\r\n \t<li>MA Comparative Drug and Alcohol Studies</li>\r\n \t<li>MA Creative Technology</li>\r\n \t<li>MA Criminology</li>\r\n \t<li>MA Education</li>\r\n \t<li>MA Fashion Communication Futures</li>\r\n \t<li>MA Fine Art</li>\r\n \t<li>MA Fine Art</li>\r\n \t<li>MA Fine Art (Printmaking)</li>\r\n \t<li>MA Fine Art (Printmaking)</li>\r\n \t<li>MA Global Governance and Sustainable Development</li>\r\n \t<li>MA Graphic Design</li>\r\n \t<li>MA Graphic Design</li>\r\n \t<li>MA Higher Education</li>\r\n \t<li>MA Human Resource Management and Development</li>\r\n \t<li>MA Interiors (Architecture and Design)</li>\r\n \t<li>MA Interiors (Architecture and Design)</li>\r\n \t<li>MA International Business Management</li>\r\n \t<li>MA International Business Management</li>\r\n \t<li>MA International Human Resource Management</li>\r\n \t<li>MA International Relations</li>\r\n \t<li>MA Leading Inclusive Education (RTL)</li>\r\n \t<li>MA Media Management</li>\r\n \t<li>MA Media Management</li>\r\n \t<li>MA Novel Writing (Distance Education)</li>\r\n \t<li>MA Photography</li>\r\n \t<li>MA Photography</li>\r\n \t<li>MA Printmaking</li>\r\n \t<li>MA Professional Practice, Artist Practitioner</li>\r\n \t<li>MA Professional Practice, Creative Industries Professional</li>\r\n \t<li>MA Professional Practice, Dance (specialisation)</li>\r\n \t<li>MA Professional Practice, Dance Technique Pedagogy</li>\r\n \t<li>MA Professional Practice, Somatic Studies</li>\r\n \t<li>MA Scriptwriting (Stage, Screen and Audio)</li>\r\n \t<li>MA Social Work</li>\r\n \t<li>MA Social Work (Top up)</li>\r\n \t<li>MA Theatre Arts</li>\r\n \t<li>MA Theatre Arts</li>\r\n \t<li>MA Youth Justice Community Safety and Applied Criminology</li>\r\n \t<li>Master of Business Administration</li>\r\n \t<li>Master of Business Administration (Blended Learning)</li>\r\n \t<li>Master of Professional Studies (Education)</li>\r\n \t<li>Master of Professional Studies (Environment)</li>\r\n \t<li>Master of Professional Studies (Health)</li>\r\n \t<li>Master of Professional Studies (Health) by Public Works</li>\r\n \t<li>Master of Professional Studies (Health) by Public Works</li>\r\n \t<li>Master of Professional Studies (Risk)</li>\r\n \t<li>Master of Professional Studies (Risk) by Public Works</li>\r\n \t<li>Master of Professional Studies (Risk) by Public Works</li>\r\n \t<li>MComp Business Information Systems</li>\r\n \t<li>MComp Computer Science</li>\r\n \t<li>MComp Information Technology</li>\r\n \t<li>MEng Biomedical Engineering</li>\r\n \t<li>MPhil within the discipline of Art &amp; Design</li>\r\n \t<li>MPhil within the discipline of Cultural Studies</li>\r\n \t<li>MPhil within the discipline of Dance</li>\r\n \t<li>MPhil within the discipline of Design Engineering</li>\r\n \t<li>MPhil within the discipline of Drama</li>\r\n \t<li>MPhil within the discipline of English</li>\r\n \t<li>MPhil within the discipline of Media Practices</li>\r\n \t<li>MPhil within the discipline of Music</li>\r\n \t<li>MPhil/PhD within the discipline of Art &amp; Design</li>\r\n \t<li>MPhil/PhD within the discipline of Cultural Studies</li>\r\n \t<li>MPhil/PhD within the discipline of Dance</li>\r\n \t<li>MPhil/PhD within the discipline of Design Engineering</li>\r\n \t<li>MPhil/PhD within the discipline of Drama</li>\r\n \t<li>MPhil/PhD within the discipline of English</li>\r\n \t<li>MPhil/PhD within the discipline of Mathematics</li>\r\n \t<li>MPhil/PhD within the discipline of Media Practices</li>\r\n \t<li>MPhil/PhD within the discipline of Music</li>\r\n \t<li>MPhil/PhD within the discipline of Product Design</li>\r\n</ul>\r\n<ul id=\"majors\">\r\n \t<li>MProf in Environment by Public Works</li>\r\n \t<li>MSc Advanced Professional Practice (Negotiated Specialism)</li>\r\n \t<li>MSc Applied Psychology</li>\r\n \t<li>MSc Applied Statistics</li>\r\n \t<li>MSc Banking and Finance</li>\r\n \t<li>MSc Behavioural Economics in Action</li>\r\n \t<li>MSc Biodiversity, Evolution and Conservation in Action</li>\r\n \t<li>MSc Biomedical Science (Cellular Pathology)</li>\r\n \t<li>MSc Biomedical Science (Clinical Biochemistry)</li>\r\n \t<li>MSc Biomedical Science (Haematology and Transfusion Science)</li>\r\n \t<li>MSc Biomedical Science (Infection and Immunity)</li>\r\n \t<li>MSc Biomedical Science (Medical Immunology)</li>\r\n \t<li>MSc Biomedical Science (Medical Microbiology)</li>\r\n \t<li>MSc Building Information Modelling and Construction Technologies (Distance Education)</li>\r\n \t<li>MSc Building Information Modelling Management and Integrated Digital Delivery</li>\r\n \t<li>MSc Business Information Systems Management</li>\r\n \t<li>MSc by Research in the Faculty of Science and Technology (Oncology)</li>\r\n \t<li>MSc by Research within the Faculty of Arts and Creative Industries</li>\r\n \t<li>MSc by Research within the school of Media and Performing Arts</li>\r\n \t<li>MSc by Research within the school of Science and Technology</li>\r\n \t<li>MSc Cancer Biology and Therapeutics</li>\r\n \t<li>MSc Cardiac Rhythm Management and Electrophysiology</li>\r\n \t<li>MSc Cardiology</li>\r\n \t<li>MSc Clinical Health Psychology and Wellbeing</li>\r\n \t<li>MSc Clinical Neuroscience</li>\r\n \t<li>MSc Cognitive and Clinical Neuroscience</li>\r\n \t<li>MSc Computational Neuroscience</li>\r\n \t<li>MSc Computer Networks and Network Design</li>\r\n \t<li>MSc Computer Science</li>\r\n \t<li>MSc Computer Science</li>\r\n \t<li>MSc Corporate and Marketing Communications</li>\r\n \t<li>MSc Creative Technology</li>\r\n \t<li>MSc Criminology with Forensic Psychology</li>\r\n \t<li>MSc Cyber Security and Pen Testing</li>\r\n \t<li>MSc Cybercrime and Digital Investigation</li>\r\n \t<li>MSc Data Science</li>\r\n \t<li>MSc Data Science</li>\r\n \t<li>MSc Developmental Psychology in Action</li>\r\n \t<li>MSc Digital Journalism</li>\r\n \t<li>MSc Digital Marketing</li>\r\n \t<li>MSc Engineering Management</li>\r\n \t<li>MSc Environmental Health</li>\r\n \t<li>MSc Exercise and Physical Activity for Special Populations and Healthy Ageing</li>\r\n \t<li>MSc Financial Management</li>\r\n \t<li>MSc Financial Mathematics</li>\r\n \t<li>MSc Global Supply Chain Management</li>\r\n \t<li>MSc Information Security Management</li>\r\n \t<li>MSc Innovation Management and Entrepreneurship</li>\r\n \t<li>MSc Intelligent Telecommunications Engineering</li>\r\n \t<li>MSc International Hospitality and Event Management</li>\r\n \t<li>MSc Investment and Finance</li>\r\n \t<li>MSc Management</li>\r\n \t<li>MSc Media Management</li>\r\n \t<li>MSc Medical Genomics</li>\r\n \t<li>MSc Mental Health and Substance Use (Dual Diagnosis)</li>\r\n \t<li>MSc Mental Health Studies</li>\r\n \t<li>MSc Network Management and Cloud Computing</li>\r\n \t<li>MSc Occupational Health, Safety and Environment Management (Apprenticeship)</li>\r\n \t<li>MSc Occupational Health, Safety and Environmental Management</li>\r\n \t<li>MSc Occupational Health, Safety and Environmental Management</li>\r\n \t<li>MSc Occupational Health, Safety and Well-Being Management</li>\r\n \t<li>MSc Occupational Health, Safety and Well-Being Management</li>\r\n \t<li>MSc Professional Aviation Pilot Practice</li>\r\n \t<li>MSc Psychological Therapies and Interventions</li>\r\n \t<li>MSc Psychology (Conversion)</li>\r\n \t<li>MSc Public Health</li>\r\n \t<li>MSc Robotics</li>\r\n \t<li>MSc Sport and Exercise Nutrition</li>\r\n \t<li>MSc Sport Performance Analysis</li>\r\n \t<li>MSc Sport Performance Analysis (Distance Education)</li>\r\n \t<li>MSc Sport Rehabilitation</li>\r\n \t<li>MSc Strategic Marketing</li>\r\n \t<li>MSc Strength and Conditioning</li>\r\n \t<li>MSc Strength and Conditioning (Distance Education)</li>\r\n \t<li>MSc Strength and Conditioning (Distance Education)</li>\r\n \t<li>MSc Sustainability and Environmental Management</li>\r\n \t<li>MSc Telecommunications Engineering</li>\r\n \t<li>MSc Transdisciplinary Practice</li>\r\n \t<li>MSci Environmental Science</li>\r\n \t<li>PGCE English (QTS)</li>\r\n \t<li>PGCE English and Drama (QTS)</li>\r\n \t<li>PGCE English and Drama (QTS)</li>\r\n \t<li>PGCE Geography with Humanities (QTS)</li>\r\n \t<li>PGCE History with Humanities (QTS)</li>\r\n \t<li>PGCE Primary Education (QTS)</li>\r\n \t<li>PGCE Science with Biology (QTS)</li>\r\n</ul>\r\n<a href=\"https://www.mdx.ac.uk/courses/postgraduate\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"http://www.facebook.com/MiddlesexUniversity\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"http://www.twitter.com/middlesexuni\" target=\"_blank\" rel=\"noopener\">\r\nTwitter\r\n</a>\r\n<a href=\"https://www.instagram.com/middlesexuniversity/?hl=en\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"http://www.youtube.com/middlesexunivideo\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.mdx.ac.uk/\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.mdx.ac.uk/study-with-us/international/support-in-your-country/usa\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.mdx.ac.uk/study-with-us/international/finance-for-international-students\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://app.geckoform.com/public/#/form/nU58Ydwp27DAWKJu\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://unihub.mdx.ac.uk/support/financial-support/us-loans-and-career-development-loans\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.mdx.ac.uk/get-in-touch/meet-us\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.mdx.ac.uk/our-research\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.mdx.ac.uk/student-life/accommodation\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.mdx.ac.uk/study-with-us/your-future-career\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.mdx.ac.uk/student-life/life-on-campus/clubs-and-societies\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"http://www.mdx.ac.uk/study-with-us/undergraduate/how-to-apply-for-undergraduate-courses\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"Middlesex University","post_link":"https://theukstudyexpert.com/universities/middlesex/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Middlesex University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Middlesex-University-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"London, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10222,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"University of Plymouth","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Plymouth\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Plymouth-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/plymouth/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Plymouth</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                The University of Plymouth is a modern city centre university located in the South West of England, nestled between the beaches of Devon and picturesque Dartmoor. Ranked as one of the UK\u2019s top 10 modern universities.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"The University of Plymouth is a modern city centre university located in the South West of England, nestled between the beaches of Devon and picturesque Dartmoor. Ranked as one of the UK\u2019s top 10 modern universities.","address":"Drake Circus, Plymouth PL4 8AA, UK","location":{"lat":"50.3758892","state":"England","country":"United Kingdom","lng":"-4.139584199999999","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/plymouth/","zoom":5,"extra_fields":{"post_excerpt":"The University of Plymouth is a modern city centre university located in the South West of England, nestled between the beaches of Devon and picturesque Dartmoor. Ranked as one of the UK\u2019s top 10 modern universities.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Plymouth.png\" alt=\"University of Plymouth\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Plymouth-1.png\" alt=\"University of Plymouth\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Plymouth-2.png\" alt=\"University of Plymouth\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Plymouth-3.png\" alt=\"University of Plymouth\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Plymouth-4.png\" alt=\"University of Plymouth\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Plymouth-5.png\" alt=\"University of Plymouth\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact University of Plymouth\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> Drake Circus, Plymouth, Devon PL4 8AA, United Kingdom</p><p><strong>Website:</strong> <a href=\"https://www.plymouth.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://plymouth.ac.uk/</a></p><h3>Overview</h3><p>The University of Plymouth is a modern city centre university located in the South West of England, nestled between the beaches of Devon and Cornwall and picturesque Dartmoor.</p><p data-rte-preserve-empty=\"true\">\u00a0</p><p>Ranked as one of the UK\u2019s top 10 modern universities, it is our aim to advance knowledge and transform lives. Plymouth is committed to investing in the future of its students, fueling their career development with degrees designed to unveil strengths, to tackle global challenges and make a positive difference to people\u2019s lives.</p><p data-rte-preserve-empty=\"true\">\u00a0</p><p>Plymouth is unlike anywhere else in the UK: a vibrant city located right on the edge of the beautiful countryside of Dartmoor and within striking\u2019s distance of the stunning beaches of Devon and Cornwall. Known as Britain\u2019s Ocean City, Plymouth is both steeped in history and undergoing fantastic redevelopment. From a multimillion-pound new city museum and art gallery, to the old cobbled streets of the Barbican, a new leisure development with IMAX cinema, to coastal views on Plymouth Hoe. You can find shopping opportunities, amazing student nightlife and stunning beaches all right on your doorstep! Best part? Our campus is right in the heart of all of this!</p><p data-rte-preserve-empty=\"true\">\u00a0</p><p>Secure the future you deserve in Britain\u2019s Ocean City.</p><p data-rte-preserve-empty=\"true\">\u00a0</p><p><strong>Population: </strong>18,000</p><p><strong>Campus Type: </strong>Urban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li><p>Founded in 1862 as the School of Navigation, the University of Plymouth is now the UK's 15th largest university</p></li><li><p>A three time award winner of the Queen's Anniversary Prize for Higher and Further Education, most recently in 2019 for marine microplastics pollution research</p></li><li><p>Ranked the number one university globally for the United Nation's Sustainable Development Goal: life below water (Times Higher Education Impact Rankings 2021)</p></li><li><p>Top UK University of Marine and Ocean Engineering (Shanghai Ranking Global Ranking of Academic Subjects 2019)</p></li><li><p>Top 10 UK Young University in the 2021 Times Higher Education Young University Rankings</p></li></ul>\t\t\n\t\t<h3>Videos</h3>https://youtu.be/7_YPSfikdOQhttps://youtu.be/H9nMHN1ywMEhttps://youtu.be/iRIBbjmj670https://youtu.be/h9XxBpmXxb8https://youtu.be/zRYs2lVmOI0https://www.youtube.com/watch?v=WAPTU5prqgU\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p>Whilst these will vary according to the course, the University of Plymouth typically welcomes applicants with a US high school diplomas with a minimum final GPA of 3.0/4.0 or above , plus any of the following:<br /><br /></p><ul data-rte-list=\"default\"><li><p>2 AP exams at grade 3, 4 or 5 (usually two or three subjects relevant to the course)</p></li><li><p>SAT minimum 1200</p></li><li><p>ACT minimum 25</p></li></ul>Some of our courses require pre-requisite subject knowledge, which must be evidenced via relevant AP tests, Honours or College level classes, or may require a portfolio and/or interview. Our entry requirements vary \u2013 courses within our Faculty of Health (Medicine, Dentistry, Biomedical Sciences and Health Professions) and Faculty of Science and Engineering (such as Marine Biology) are relatively high with exams required in related subjects, whereas other courses are flexible both in terms of subjects and grades. Please refer to individual course pages for further information.<br /><br />Please note that competitive courses may have higher entry requirements.\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Accounting and Finance BA</li><li>Accounting and Finance with Foundation Year BA</li><li>Acting BA</li><li>Acting with Foundation BA</li><li>Advanced Psychology MPsych</li><li>Analytical Chemistry MChem</li><li>Animal Behaviour and Welfare BSc</li><li>Anthropology BA</li><li>Architectural Engineering BSc</li><li>Architecture BA</li><li>Art History BA</li><li>Biological Sciences BSc</li><li>Biological Sciences with Foundation Year BSc</li><li>Biomedical Science BSc</li><li>Biomedical Science with Integrated Foundation Year BSc</li><li>Biosciences (top-up) BSc</li><li>Building Surveying BSc</li><li>Business (top-up) BA</li><li>Business Economics BSc</li><li>Business Management BSc</li><li>Business Management (2 year Fast Track) BSc</li><li>Business Management with Foundation Year BSc</li><li>Business Management with Foundation Year (2 year Fast Track) BSc</li><li>Certificate in Education (incorporating the Diploma in Education and Training) CertEd</li><li>Chemistry BSc</li><li>Chemistry with Foundation Year BSc</li><li>Civil and Coastal Engineering BEng</li><li>Civil and Coastal Engineering MEng</li><li>Civil Engineering BEng</li><li>Civil Engineering MEng</li><li>Civil Engineering with Foundation Year BEng</li><li>Clinical Physiology BSc</li><li>Clinical Psychology MPsych</li><li>Computer Science BSc</li><li>Computing, Audio and Music Technology BSc</li><li>Computing and Software Development BSc</li><li>Computer Science with Foundation Year BSc</li><li>Conservation Biology BSc</li><li>Construction Project Management BSc</li><li>Creative and Professional Writing BA</li><li>Creative Media BA</li><li>Creative Media with Foundation BA</li><li>Criminology and Criminal Justice BSc</li><li>Criminology and Criminal Justice (Policing and Security Management) BSc</li><li>Criminology and Criminal Justice with International Relations BSc</li><li>Criminology and Criminal Justice with Psychology BSc</li><li>Criminology and Criminal Justice with Sociology BSc</li><li>Critical Care BSc</li><li>Cyber Security BSc</li><li>Dance BA</li><li>Dance with Foundation BA</li><li>Dental Surgery BDS</li><li>Dental Therapy and Hygiene BSc</li><li>Dental Therapy and Hygiene with Integrated Foundation Year BSc</li><li>Diagnostic Radiography BSc</li><li>Diagnostic Radiography with Foundation Ultrasonography BSc</li><li>Diagnostic Radiography with Integrated Foundation Year BSc</li><li>Dietetics BSc</li><li>Digital Design and Engineering BA</li><li>Digital Media Design BA</li><li>Digital Media Design BSc</li><li>Digital Media Design (Information Design) BA</li><li>Digital Media Design (Information Design) BSc</li><li>Digital Media Design (Interaction Design) BA</li><li>Digital Media Design (Interaction Design) BSc</li><li>Digital Media Design (Game Design) BA</li><li>Digital Media Design (Game Design) BSc</li><li>Digital Media Design (Live Media Design) BA</li><li>Digital Media Design (Live Media Design) BSc</li><li>Directing BA Drama and Theatre Practice BA</li><li>Drama and Theatre Practice with Foundation BA</li><li>Early Childhood Studies BA Early Childhood Studies (top-up) BA</li><li>Early Childhood Studies with Foundation BA</li><li>Economics BSc</li><li>Economics (Financial pathway) BSc</li><li>Economics with Foundation Year BSc</li><li>Education BA Education (top-up) BA</li><li>Education with Foundation BA</li><li>Electrical and Electronic Engineering BEng</li><li>Electrical and Electronic Engineering MEng</li><li>Electrical and Electronic Engineering with Foundation Year BEng</li><li>English BA</li><li>English and Creative Writing BA</li><li>English and Creative Writing with Foundation BA</li><li>English with Foundation BA</li><li>English with History BA</li><li>English with Publishing BA</li><li>Environmental Geoscience BSc</li><li>Environmental Management and Sustainability BSc</li><li>Environmental Science BSc</li><li>Environmental Science with Foundation Year BSc</li><li>Events Management BSc</li><li>Events Management with Foundation Year BSc</li><li>Filmmaking BA Financial Economics (top-up) BSc</li><li>Fine Art BA</li><li>Fine Art and Art History BA</li><li>Fine Art with Foundation BA</li><li>Game Arts and Design BA</li><li>Games Development Technologies BSc</li><li>Geography BA</li><li>Geography BSc</li><li>Geography with International Relations BA</li><li>Geography with Ocean Science BSc</li><li>Geology BSc</li><li>Geology MGeol</li><li>Geology with Foundation Year BSc</li><li>Geology with Ocean Science BSc</li></ul><ul id=\"majors\"><li>Graphic Design with Typography BA</li><li>Graphic Design with Typography (Digital and Experience) BA</li><li>Graphic Design with Typography (Editorial and Publishing) BA</li><li>Graphic Design with Typography (Identity and Branding) BA</li><li>Graphic Design with Typography with Foundation BA</li><li>History BA</li><li>History with English BA</li><li>History with Foundation BA</li><li>History with International Relations BA</li><li>History with Politics BA</li><li>Hospitality, Tourism and Events Management (top-up) BA</li><li>Human Biosciences BSc</li><li>Human Neuroscience MPsych</li><li>Human Resource Management (top-up) BA</li><li>Illustration BA</li><li>Illustration (Animation &amp; the Screen) BA</li><li>Illustration (Children&#8217;s Markets) BA</li><li>Illustration (Comics &amp; Visual Narrative) BA</li><li>Illustration (Printmaking) BA</li><li>Illustration with Foundation BA</li><li>Interior Design BA</li><li>International Business Management (top-up) BSc</li><li>International Finance (top-up) BA</li><li>International Management (top-up) BA</li><li>International Relations BSc</li><li>International Relations with Politics BSc</li><li>International Relations with Politics with Foundation BSc</li><li>International Supply Chain and Shipping Management (top-up) BSc</li><li>International Tourism Management BSc</li><li>International Tourism Management with Foundation BSc</li><li>Law LLB</li><li>Law with Criminology and Criminal Justice LLB</li><li>Law with Foundation LLB</li><li>Marine Biology BSc</li><li>Marine Biology and Coastal Ecology BSc</li><li>Marine Biology and Oceanography BSc</li><li>Marine Biology with Foundation Year BSc</li><li>Marine Technology BEng</li><li>Marine Technology MEng</li><li>Marine Technology with Composites BEng</li><li>Marine Technology with Composites MEng</li><li>Maritime Business BSc</li><li>Maritime Business (International Supply Chain Management) BSc</li><li>Maritime Business (Logistics) BSc</li><li>Maritime Business (Maritime Law) BSc</li><li>Maritime Business with Foundation Year BSc</li><li>Marketing BSc</li><li>Marketing with Foundation Year BSc</li><li>Mathematics BSc</li><li>Mathematics and Statistics BSc</li><li>Mathematics with Education BSc</li><li>Mathematics with Finance BSc</li><li>Mathematics with Foundation Year BSc</li><li>Mathematics with Theoretical Physics BSc</li><li>Mechanical Engineering BEng</li><li>Mechanical Engineering MEng</li><li>Mechanical Engineering with Composites BEng</li><li>Mechanical Engineering with Composites MEng</li><li>Mechanical Engineering with Foundation Year BEng</li><li>Medicine BMBS</li><li>Medicine with Foundation Year BMBS</li><li>Midwifery BSc</li><li>Music BA</li><li>Music: Composition BA</li><li>Music: Ethnomusicology BA</li><li>Music: Performance BA</li><li>Music: Technology BA</li><li>Navigation and Maritime Science BSc</li><li>Navigation and Maritime Science FdSc</li><li>Nursing \u2013 Adult Health BSc</li><li>Nursing \u2013 Adult Health BSc</li><li>Nursing \u2013 Child Health BSc</li><li>Nursing \u2013 Child Health BSc</li><li>Nursing \u2013 Mental Health BSc</li><li>Nursing \u2013 Mental Health BSc</li><li>Nursing (Adult Health and Child Health) MNurs</li><li>Nursing (Adult Health and Mental Health) MNurs</li><li>Nursing (Child Health and Mental Health) MNurs</li><li>Nutrition, Exercise and Health BSc</li><li>Occupational Therapy BSc</li><li>Occupational Therapy MOccTh</li><li>Ocean Exploration and Surveying BSc</li><li>Ocean Science and Marine Conservation BSc</li><li>Ocean Sciences with Foundation Year BSc</li><li>Oceanography and Coastal Processes BSc</li><li>Optometry BSc</li><li>Paramedic Science BSc</li><li>Photography BA</li><li>Photography with Foundation BA</li><li>Physical Geography and Geology BSc</li><li>Physiotherapy BSc</li><li>Physiotherapy MPhysio</li><li>Podiatry BSc</li><li>Politics with International Relations BSc</li><li>Politics with Law BSc</li><li>Pre-Registration Midwifery BSc</li><li>Primary (Foundation Stage 1/Key Stage 1 with QTS)</li><li>BEd Primary (Key Stage 1/Key Stage 2 with QTS) BEd</li><li>Primary (Special Educational Needs with QTS) BEd</li><li>Product and Furniture Design BA</li><li>Professional Development Courses BSc</li><li>Psychological Studies (top-up) BSc</li><li>Psychology BSc</li><li>Psychology: Advanced MPsych</li><li>Psychology with Criminology and Criminal Justice Studies BSc</li><li>Psychology with Human Biology BSc</li><li>Psychology with Sociology BSc</li><li>Quantity Surveying BSc</li><li>Robotics BEng</li><li>Robotics MEng</li><li>Robotics with Foundation Year BEng</li><li>Social Work BA</li><li>Sociology BSc</li><li>Sociology with Foundation BSc</li><li>Urgent and Emergency Care BSc</li><li>Virtual Reality Design BA</li><li>Zoology BSc</li></ul>\n\t\t\t<a href=\"http://www.plymouth.ac.uk/study/undergraduate\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>To apply for our postgraduate courses from the USA, you'll need a minimum GPA 3.0/4.0 undergraduate degree in a relevant subject.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Acting MA</li><li>Advanced Critical Care Practitioner MSc/PgDip</li><li>Advanced Engineering Design MSc</li><li>Advanced Neonatal Nurse Practitioner MSc/PgDip/PgCert</li><li>Advanced Professional Practice (Clinical Practitioner) MSc/PgDip/PgCert</li><li>Advanced Professional Practice (Health and Social Care Professions) MSc/PgDip/PgCert</li><li>Advanced Professional Practice (Mental Health Practitioner) MSc/PgDip/PgCert</li><li>Advanced Professional Practice (Nursing and Midwifery Professions) MSc/PgDip/PgCert</li><li>Advanced Professional Practice in Dietetics MSc/PgDip/PgCert</li><li>Advanced Professional Practice in Medicine in Hazardous Area Response MSc/PgDip/PgCert</li><li>Advanced Professional Practice in Neurological Rehabilitation MSc/PgDip/PgCert</li><li>Advanced Professional Practice in Occupational Therapy MSc/PgDip/PgCert</li><li>Advanced Professional Practice in Paediatric Dietetics MSc/PgDip/PgCert</li><li>Advanced Professional Practice in Physiotherapy MSc/PgDip/PgCert</li><li>Advanced Psychology MSc</li><li>Applied Marine Science MSc/MRes</li><li>Architectural Design MA</li><li>Architecture M.Arch</li><li>Archival Practice MA</li><li>Art History ResM</li><li>Artificial Intelligence MSc</li><li>Autonomous Systems MSc</li><li>Biomedical Science (Cancer Biology, Clinical Neuroscience or Infection and Immunity) MSc</li><li>Biomedical Sciences MPhil/PhD</li><li>Biomedical Sciences ResM</li><li>Business and Management MSc</li><li>Civil Engineering MSc</li><li>Clinical Education MClinEd/PgCert</li><li>Clinical Psychology MSc/PgDip/PgCert</li><li>Clinical Research MClinRes/PgDip/PgCert</li><li>Clinical Sciences MSc</li><li>Coastal Engineering MSc</li><li>Computer Music ResM</li><li>Creative Writing MA</li><li>Criminology MSc</li><li>Cyber Security MSc</li><li>Dance ResM</li><li>Data Science and Business Analytics MSc</li><li>Dental Studies MPhil/PhD Dental Studies ResM</li><li>Design MA Design: Brand Design MA</li><li>Design: Design for Engineering Systems MA</li><li>Design: Design for Information MA</li><li>Design: Design Products MA</li><li>Design: Design Thinking for Social Innovation MA</li><li>Design: Maker and Materials MA</li><li>Design: Service and Interaction Design MA</li><li>Design: Spatial Design MA</li><li>Design Management: Sustainable Futures MA</li><li>Digital and Social Media Marketing MSc</li><li>Digital Art and Technology MRes</li><li>District Nursing* PgDip/PgCert</li><li>Education MA</li><li>Education: Autism PgCert</li><li>Electrical and Electronic Engineering MSc</li><li>English ResM</li><li>English Literature MA</li><li>Environmental and Engineering Geology MSc</li><li>Environmental Consultancy MSc</li><li>Environmental Geochemistry MSc</li><li>Environmental Humanities MA</li><li>Finance MSc</li><li>Fine Art MA</li><li>Game Design MA</li><li>Global Health (Leadership) MSc</li><li>Global Health (Remote and Rural) MSc</li></ul><ul id=\"majors\"><li>Healthcare Improvement and Patient Safety MSc/PgDip/PgCert</li><li>Healthcare Management, Leadership and Innovation MSc/PgDip/PgCert</li><li>Heritage Theory and Practice MA</li><li>High Performance Buildings MSc</li><li>History MA</li><li>History ResM</li><li>Human Geography Research MSc</li><li>Human Neuroscience MSc</li><li>Human Nutrition MSc/PgDip/PgCert</li><li>Human Resource Management MA</li><li>Hydrography MSc</li><li>Illustration MA</li><li>Integrated Design Innovation MA/MSc</li><li>International Business MSc/PgDip/PgCert</li><li>International Logistics and Supply Chain Management MSc/PgDip/PgCert</li><li>International Procurement and Supply Chain Management MSc/PgDip</li><li>International Relations: Global Security and Development MA/MRes/PgDip/PgCert</li><li>International Shipping MSc/PgDip/PgCert</li><li>Law LLM</li><li>Marine Biology MRes</li><li>Marine Conservation MSc</li><li>Maritime History MA</li><li>MArch Architecture MA</li><li>Master of Business Administration MBA</li><li>Master of Business Administration (Entrepreneurship) MBA</li><li>Master of Business Administration (Finance) MBA</li><li>Master of Business Administration (Global Supply Chain Management) MBA</li><li>Master of Business Administration (Human Resource Management) MBA</li><li>Master of Business Administration (Maritime Business Management) MBA</li><li>Master of Business Administration (Marketing) MBA</li><li>Master of Business Administration (Operations Management) MBA</li><li>Mathematics Education MA</li><li>Medical Studies MPhil/PhD</li><li>Medical Studies ResM</li><li>Midwifery (Pre-registration) MSc</li><li>Music MA</li><li>Occupational Therapy (Pre-registration) MSc</li><li>Offshore Renewable Energy MSc/MRes</li><li>Offshore Renewable Energy Engineering MSc</li><li>Operations and Supply Chain Management MSc</li><li>Oral Surgery MSc/PgDip/PgCert</li><li>Performance Training MA/MFA</li><li>Periodontology MSc/PgDip/PgCert</li><li>PGCE (incorporating the Diploma in Education and Training) PGCE</li><li>PGCE Primary (3\u20137) PGCE</li><li>PGCE Primary (5\u201311) PGCE</li><li>PGCE Secondary PGCE</li><li>PGCE Secondary: Art and Design PGCE</li><li>PGCE Secondary: Drama PGCE</li><li>PGCE Secondary: English PGCE</li><li>PGCE Secondary: Geography PGCE</li><li>PGCE Secondary: History PGCE</li><li>PGCE Secondary: Mathematics PGCE</li><li>PGCE Secondary: Music PGCE</li><li>PGCE Secondary: Sciences (Biology, Chemistry or Physics) PGCE</li><li>Photographic Arts MFA</li><li>Photography MA</li><li>Physician Associate Studies MSc/PgDip/PgCert</li><li>Physiotherapy (Pre-registration) MSc</li><li>Planning MSc</li><li>Pre-registration Nursing (Adult Health) MSc</li><li>Pre-registration Nursing (Child Health) MSc</li><li>Pre-registration Nursing (Mental Health) MSc</li><li>Psychology MSc</li><li>Publishing MA</li><li>Restorative Dentistry MSc/PgDip/PgCert</li><li>Robotics MSc/MRes</li><li>Smart Urban Futures MA</li><li>Social Research MSc</li><li>Surgical Care Practitioner (Abdominal, Pelvic and General Surgery) MSc/PgDip</li><li>Surgical Care Practitioner (Cardiothoracic Surgery) MSc/PgDip</li><li>Surgical Care Practitioner (Trauma and Orthopaedic Surgery) MSc/PgDip</li><li>Sustainable Aquaculture MSc</li><li>Sustainable Environmental Management MSc/MRes/PgDip</li><li>Theatre and Performance ResM</li><li>Tourism and Hospitality ResM</li><li>Tourism and Hospitality Management MSc/PgDip</li><li>Zoo Conservation Biology MSc/PgDip</li></ul>\n\t\t\t<a href=\"http://www.plymouth.ac.uk/study/postgraduate\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"http://www.facebook.com/plymouthuni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.twitter.com/plymuni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.instagram.com/plymuni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.youtube.com/user/PlymouthUniversity\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.plymouth.ac.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.plymouth.ac.uk/international/study/international-students-country-guides/the-americas/united-states-of-america\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.plymouth.ac.uk/study/fees\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.plymouth.ac.uk/study/funding/international\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.plymouth.ac.uk/study/funding/international\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.plymouth.ac.uk/about-us/virtual-tour\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.plymouth.ac.uk/study/research-degrees\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.plymouth.ac.uk/services/accommodation\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.plymouth.ac.uk/careers-and-employment/degrees\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.upsu.com/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"http://www.plymouth.ac.uk/international/how-to-apply\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"University of Plymouth","post_link":"https://theukstudyexpert.com/universities/plymouth/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Plymouth\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Plymouth-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"Plymouth, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10220,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Royal Holloway University of London","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Royal Hollway University of London\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Royal-Hollway-University-of-London-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/royal-holloway/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Royal Holloway University of London</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Royal Holloway University of London, is ranked in the top 30 universities in the UK (The Guardian League Table, 2023) offering a stunning Victorian campus with a wide range of courses in the sciences, humanities, and arts.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Royal Holloway University of London, is ranked in the top 30 universities in the UK (The Guardian League Table, 2023) offering a stunning Victorian campus with a wide range of courses in the sciences, humanities, and arts.","address":"Royal Holloway University of L, Egham Hill, Egham TW20 0EQ, UK","location":{"lat":"51.42551160000001","state":"England","country":"United Kingdom","lng":"-0.5613291000000001","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/royal-holloway/","zoom":5,"extra_fields":{"post_excerpt":"Royal Holloway University of London, is ranked in the top 30 universities in the UK (The Guardian League Table, 2023) offering a stunning Victorian campus with a wide range of courses in the sciences, humanities, and arts.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Royal-Holloway.png\" alt=\"Royal Holloway University of London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Royal-Holloway-1.png\" alt=\"Royal Holloway University of London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Royal-Holloway-2.png\" alt=\"Royal Holloway University of London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Royal-Holloway-3.png\" alt=\"Royal Holloway University of London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Royal-Holloway-4.png\" alt=\"Royal Holloway University of London\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Royal-Holloway-5.png\" alt=\"Royal Holloway University of London\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact Royal Holloway, University of London\r\n</a>\r\n\r\n<strong>Location:</strong> Egham Hill, Egham, England, UK, TW20 0EX\r\n\r\n<strong>Website:</strong> <a href=\"http://www.royalholloway.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://royalholloway.ac.uk/</a>\r\n<h3>Overview</h3>\r\nRoyal Holloway, University of London, is ranked in the top 30 universities in the UK (The Guardian University League Table, 2023). Through world-class research that expands minds and changes lives, the dedication of our teachers and the feel of the Royal Holloway experience, ours is a community that inspires individuals to succeed academically, socially and personally.\r\n\r\nThe university was founded by two social reformers who pioneered the ideal of education and knowledge for all who could benefit. Their vision lives on today. As one of the UK\u2019s leading research-intensive universities we are home to some of the world\u2019s foremost authorities in the sciences, arts, business, economics and law.\r\n\r\nWe are strengthened by diversity, and welcome students and academics who travel from all over the world to study and work here, ensuring an international and multicultural perspective within a close knit and historic campus.\r\n\r\n<strong>Population: </strong>11,732\r\n\r\n<strong>Campus Type: </strong>Suburban\r\n<h3>Quick Facts</h3>\r\n<ul>\r\n \t<li>Open in 1849 as the first women\u2019s higher education college in Great Britain</li>\r\n \t<li>Set on 134 acres of beautiful parkland, our Egham campus is often voted one of the most beautiful campuses in the UK. The Grade 1 listed Founder\u2019s Building was opened in 1886 by Queen Victoria.</li>\r\n \t<li>Within the top 25% of universities in the UK for research which is rated \u2018world-leading\u2019 (4*) or \u2018internationally excellent\u2019 (3*) (REF, 2021)</li>\r\n \t<li>25 departments across 6 academic schools, covering degrees from Accounting to Zoology and much more.</li>\r\n \t<li>Over 100,000 alumni from Royal Holloway and Bedford New College worldwide.</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://www.youtube.com/watch?v=xGPC0cKDgZohttps://www.youtube.com/watch?v=lTDJP6hxsbMhttps://www.youtube.com/watch?v=t_ZesMODH1A\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nStudents would be eligible to study at undergraduate level by achieving the grade noted in <strong>one</strong> of the following qualifications:\r\n<ul data-rte-list=\"default\">\r\n \t<li><strong>Advanced Placement Exams (AP\u2019s)</strong> - The standard entry requirement for applicants with American qualifications is Advanced Placement Exams. You will need grades of 3+ in at least 2 AP Exams.\r\n\r\n<em>Some subjects require subject-specific AP\u2019s, please review individual course pages for more information.</em></li>\r\n</ul>\r\n<ul data-rte-list=\"default\">\r\n \t<li><strong>SAT</strong> - Score of 1040-1200 overall in the New SAT reasoning test + one AP with a grade 3+.\r\n\r\n<em>Some subjects require subject-specific AP\u2019s, please review individual course pages for more information.</em></li>\r\n</ul>\r\n<ul data-rte-list=\"default\">\r\n \t<li><strong>ACT</strong> - Composite score of 21-27 in the ACT Examinations (including the ACT writing test) + one AP grade 3+.</li>\r\n</ul>\r\n<em>Some subjects may require subject-specific AP\u2019s or a higher AP exam, please review individual pages for more information.\u00a0</em>Specific grades for each course can be found on course finder and selecting \u201cUSA\u201d under International &amp; EU requirements.\r\n<ul data-rte-list=\"default\">\r\n \t<li><strong>International Baccalaureate (IB)</strong> - If you have taken the IB Diploma you will be considered for direct entry onto our undergraduate programmes. Specific grade requirements are in the course finder entry for your chosen course.</li>\r\n</ul>\r\n<ul data-rte-list=\"default\">\r\n \t<li><strong>Associate Degree</strong> - Associate Degree with a GPA of at least 3.0 (year 1 entry; year 2 entry may be considered by a case by case basis).\r\n<p data-rte-preserve-empty=\"true\"></p>\r\n</li>\r\n</ul>\r\n<strong>College Board number</strong> - If you need to send us official transcripts of your standardised tests please quote Royal Holloway's College Board number (CEEB number) 4899.\r\n\r\n<strong>University preparation programmes</strong> - The Royal Holloway International Study Centre provides an International Foundation Year and International Year One programme, which are designed for international students who do not quite meet the requirements for an undergraduate course. These programmes will help to develop your academic and English language skills in preparation for university. Upon successful completion, you can progress to degree level study at Royal Holloway, University of London.\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n<ul id=\"majors\">\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li>Accounting and Finance BSc</li>\r\n \t<li>Biochemistry BSc</li>\r\n \t<li>Biology BSc</li>\r\n \t<li>Biomedical Sciences BSc</li>\r\n \t<li>Ecology and Conservation BSc</li>\r\n \t<li>Genetics BSc</li>\r\n \t<li>Medical Biochemistry BSc</li>\r\n \t<li>Molecular Biology and Environmental Change BSc</li>\r\n \t<li>Zoology BSc</li>\r\n \t<li>Business and Management BSc</li>\r\n \t<li>Management with Accounting BSc</li>\r\n \t<li>Management with Corporate Responsibility BSc</li>\r\n \t<li>Management with Digital Innovation BSc</li>\r\n \t<li>Management with Entrepreneurship BSc</li>\r\n \t<li>Management with Human Resources BSc</li>\r\n \t<li>Management with International Business BSc</li>\r\n \t<li>Management with Marketing BSc</li>\r\n \t<li>Ancient &amp; Medieval History BA</li>\r\n \t<li>Ancient History &amp; Philosophy BA</li>\r\n \t<li>Ancient History BA</li>\r\n \t<li>Ancient History with Philosophy BA</li>\r\n \t<li>Classical Archaeology and Ancient History BA</li>\r\n \t<li>Classical Studies &amp; Comparative Literature and Culture BA</li>\r\n \t<li>Classical Studies &amp; Drama BA</li>\r\n \t<li>Classical Studies &amp; Philosophy BA</li>\r\n \t<li>Classical Studies BA</li>\r\n \t<li>Classical Studies with Philosophy BA</li>\r\n \t<li>Classics &amp; Philosophy BA</li>\r\n \t<li>Classics BA</li>\r\n \t<li>Classics with Philosophy BA</li>\r\n \t<li>Greek BA</li>\r\n \t<li>Latin BA</li>\r\n \t<li>Computer Science &amp; Mathematics BSc</li>\r\n \t<li>Computer Science (Artificial Intelligence) BSc</li>\r\n \t<li>Computer Science (Artificial Intelligence) Msci</li>\r\n \t<li>Computer Science (Information Security) BSc</li>\r\n \t<li>Computer Science (Information Security) MSci</li>\r\n \t<li>Computer Science (Software Engineering) BSc</li>\r\n \t<li>Computer Science (Software Engineering) Msci</li>\r\n \t<li>Computer Science BSc</li>\r\n \t<li>Computer Science Msci</li>\r\n \t<li>Drama &amp; Creative Writing BA</li>\r\n \t<li>Drama &amp; Philosophy BA</li>\r\n \t<li>Drama and Theatre Studies BA</li>\r\n \t<li>Drama with Acting BA</li>\r\n \t<li>Drama with Dance BA</li>\r\n \t<li>Drama with Film BA</li>\r\n \t<li>Drama with Philosophy BA</li>\r\n \t<li>Theatre &amp; Music BA</li>\r\n \t<li>Earth, Climate and Environmental Change BSc</li>\r\n \t<li>Earth, Climate and Environmental Change MSci</li>\r\n \t<li>Environmental Geology BSc</li>\r\n \t<li>Environmental Geoscience MSci</li>\r\n \t<li>Environmental Geoscience with an International Year MSci</li>\r\n \t<li>Geology BSc</li>\r\n \t<li>Geoscience MSci</li>\r\n \t<li>Geoscience with a Year of International Study MSci</li>\r\n \t<li>Geosciences and Sustainable Energy BSc</li>\r\n \t<li>Corporate Finance MSci</li>\r\n \t<li>Economics &amp; Management BSc</li>\r\n \t<li>Economics &amp; Mathematics BSc</li>\r\n \t<li>Economics and Data Science BSc (Econ)</li>\r\n \t<li>Economics BSc (Econ)</li>\r\n \t<li>Economics MSci (Econ)</li>\r\n \t<li>Economics with French BSc (Econ)</li>\r\n \t<li>Economics with German BSc (Econ)</li>\r\n \t<li>Economics with Italian BSc (Econ)</li>\r\n \t<li>Economics with Music BSc (Econ)</li>\r\n \t<li>Economics with Political Studies BSc (Econ)</li>\r\n \t<li>Economics with Spanish BSc (Econ)</li>\r\n \t<li>Economics, Politics and International Relations BSc</li>\r\n \t<li>Finance &amp; Mathematics BSc</li>\r\n \t<li>Finance MSci</li>\r\n \t<li>Financial and Business Economics BSc (Econ)</li>\r\n \t<li>Computer Systems Engineering Beng</li>\r\n \t<li>Computer Systems Engineering Meng</li>\r\n \t<li>Electronic Engineering Beng</li>\r\n \t<li>Electronic Engineering Meng</li>\r\n \t<li>American Literature and Creative Writing BA</li>\r\n \t<li>English &amp; Classical Studies BA</li>\r\n \t<li>English &amp; Digital Arts BA</li>\r\n \t<li>English &amp; Drama BA</li>\r\n \t<li>English &amp; Film Studies BA</li>\r\n \t<li>English &amp; History BA</li>\r\n \t<li>English &amp; Latin BA</li>\r\n \t<li>English &amp; Philosophy BA</li>\r\n \t<li>English and American Literature BA</li>\r\n \t<li>English and Creative Writing BA</li>\r\n \t<li>English BA</li>\r\n \t<li>English with Philosophy BA</li>\r\n \t<li>Environment and Social Change BSc</li>\r\n \t<li>Geography BA</li>\r\n \t<li>Geography BSc</li>\r\n \t<li>Geography, Culture and Identity BA</li>\r\n \t<li>Geography, Environment and Climate BSc</li>\r\n \t<li>Geography, Geopolitics and Global Affairs BA</li>\r\n \t<li>Human Geography BA</li>\r\n \t<li>Physical Geography BSc</li>\r\n \t<li>Health Studies BSc</li>\r\n \t<li>History &amp; Music BA</li>\r\n \t<li>History &amp; Philosophy BA</li>\r\n \t<li>History BA</li>\r\n \t<li>History, Politics and International Relations BA</li>\r\n \t<li>Modern and Contemporary History BA</li>\r\n \t<li>Comparative Literature and Culture &amp; Drama BA</li>\r\n \t<li>Comparative Literature and Culture &amp; English BA</li>\r\n \t<li>Comparative Literature and Culture &amp; History of Art and Visual Culture BA</li>\r\n \t<li>Comparative Literature and Culture &amp; Philosophy BA</li>\r\n \t<li>Comparative Literature and Culture BA</li>\r\n \t<li>Comparative Literature and Culture with History of Art and Visual Culture BA</li>\r\n \t<li>Comparative Literature and Culture with International Film BA</li>\r\n \t<li>Comparative Literature and Culture with Philosophy BA</li>\r\n</ul>\r\n</li>\r\n</ul>\r\n<ul id=\"majors\">\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li>Modern Languages &amp; Classical Studies BA</li>\r\n \t<li>Modern Languages &amp; Comparative Literature and Culture BA</li>\r\n \t<li>Modern Languages &amp; Drama BA</li>\r\n \t<li>Modern Languages &amp; English BA</li>\r\n \t<li>Modern Languages &amp; Greek BA</li>\r\n \t<li>Modern Languages &amp; History BA</li>\r\n \t<li>Modern Languages &amp; History of Art and Visual Culture BA</li>\r\n \t<li>Modern Languages &amp; Latin BA</li>\r\n \t<li>Modern Languages &amp; Management BA</li>\r\n \t<li>Modern Languages &amp; Music BA</li>\r\n \t<li>Modern Languages &amp; Philosophy BA</li>\r\n \t<li>Modern Languages &amp; Translation Studies BA</li>\r\n \t<li>Modern Languages BA</li>\r\n \t<li>Modern Languages with History of Art and Visual Culture BA</li>\r\n \t<li>Modern Languages with International Film BA</li>\r\n \t<li>Modern Languages with International Relations BA</li>\r\n \t<li>Modern Languages with Music BA</li>\r\n \t<li>Modern Languages with Philosophy BA</li>\r\n \t<li>Modern Languages with Translation Studies BA</li>\r\n \t<li>Translation Studies and Comparative Literature and Culture BA</li>\r\n \t<li>Translation Studies and History of Art and Visual Culture BA</li>\r\n \t<li>Translation Studies BA</li>\r\n \t<li>Translation Studies with History of Art and Visual Culture BA</li>\r\n \t<li>Translation Studies with International Film BA</li>\r\n \t<li>Criminology &amp; Psychology BSc</li>\r\n \t<li>Criminology and Sociology BSc</li>\r\n \t<li>Law LLB</li>\r\n \t<li>Law with Criminology LLB</li>\r\n \t<li>Law with International Relations LLB</li>\r\n \t<li>Law with Modern Languages (French) LLB</li>\r\n \t<li>Law with Modern Languages (German) LLB</li>\r\n \t<li>Law with Modern Languages (Italian) LLB</li>\r\n \t<li>Law with Modern Languages (Spanish) LLB</li>\r\n \t<li>Law with Philosophy LLB</li>\r\n \t<li>Law with Politics LLB</li>\r\n \t<li>Law with Sociology LLB</li>\r\n \t<li>Sociology &amp; Philosophy BA</li>\r\n \t<li>Liberal Arts BA</li>\r\n \t<li>Liberal Arts with a Language Year Abroad BA</li>\r\n \t<li>Liberal Arts with an International Year BA</li>\r\n \t<li>Mathematical Studies BSc</li>\r\n \t<li>Mathematics &amp; Music BA</li>\r\n \t<li>Mathematics &amp; Philosophy BSc</li>\r\n \t<li>Mathematics &amp; Physics BSc</li>\r\n \t<li>Mathematics &amp; Physics MSci</li>\r\n \t<li>Mathematics BSc</li>\r\n \t<li>Mathematics MSci</li>\r\n \t<li>Mathematics with French BSc</li>\r\n \t<li>Mathematics with German BSc</li>\r\n \t<li>Mathematics with Italian BSc</li>\r\n \t<li>Mathematics with Philosophy BSc</li>\r\n \t<li>Mathematics with Spanish BSc</li>\r\n \t<li>Mathematics with Statistics BSc</li>\r\n \t<li>Digital Media Culture and Technology BA</li>\r\n \t<li>Digital Media Culture and Technology BSc</li>\r\n \t<li>Film Studies BA</li>\r\n \t<li>Film Studies with Philosophy BA</li>\r\n \t<li>Film, Television and Digital Production BA</li>\r\n \t<li>Video Games Art and Design BA</li>\r\n \t<li>Music &amp; English BA</li>\r\n \t<li>Music &amp; Philosophy BA</li>\r\n \t<li>Music and Sound Design for Film, Television and Interactive edia BA</li>\r\n \t<li>Music BMus</li>\r\n \t<li>Music with French BA</li>\r\n \t<li>Music with German BA</li>\r\n \t<li>Music with Italian BA</li>\r\n \t<li>Music with Philosophy BA</li>\r\n \t<li>Music with Political Studies BA</li>\r\n \t<li>Music with Spanish BA</li>\r\n \t<li>Philosophy &amp; History of Art and Visual Culture BA</li>\r\n \t<li>Philosophy &amp; Law BA</li>\r\n \t<li>Philosophy BA</li>\r\n \t<li>Philosophy with International Relations BA</li>\r\n \t<li>Philosophy with Politics BA</li>\r\n \t<li>Astrophysics BSc</li>\r\n \t<li>Astrophysics MSci</li>\r\n \t<li>Physics BSc</li>\r\n \t<li>Physics MSci</li>\r\n \t<li>Physics with Music BSc</li>\r\n \t<li>Physics with Particle Physics BSc</li>\r\n \t<li>Physics with Particle Physics MSci</li>\r\n \t<li>Physics with Philosophy BSc</li>\r\n \t<li>Theoretical Physics BSc</li>\r\n \t<li>Theoretical Physics MSci</li>\r\n \t<li>International Relations BA</li>\r\n \t<li>Politics &amp; Law BA</li>\r\n \t<li>Politics and International Relations &amp; Philosophy BA</li>\r\n \t<li>Politics and International Relations BA</li>\r\n \t<li>Politics BA</li>\r\n \t<li>Politics with Philosophy BA</li>\r\n \t<li>Politics, International Relations &amp; Modern Languages (French) BA</li>\r\n \t<li>Politics, International Relations &amp; Modern Languages (German) BA</li>\r\n \t<li>Politics, International Relations &amp; Modern Languages (Italian) BA</li>\r\n \t<li>Politics, International Relations &amp; Modern Languages (Spanish) BA</li>\r\n \t<li>Politics, Philosophy &amp; Economics (PPE) BA</li>\r\n \t<li>Applied Psychology BSc</li>\r\n \t<li>Psychology BSc</li>\r\n \t<li>Psychology MSci</li>\r\n \t<li>Psychology, Clinical &amp; Cognitive Neuroscience BSc</li>\r\n \t<li>Psychology, Clinical Psychology &amp; Mental Health BSc</li>\r\n \t<li>Psychology, Development &amp; Developmental Disorders BSc</li>\r\n \t<li>Health and Social Care BSc</li>\r\n \t<li>Social Science BSc</li>\r\n</ul>\r\n</li>\r\n</ul>\r\n<a href=\"http://www.royalholloway.ac.uk/studying-here/\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\n<strong>Master\u2019s Degree</strong>\r\n\r\nIf you have a Bachelors degree in an appropriate subject with good grades/GPA and from a reputable university, you will be considered for entry to a Royal Holloway Master's degree programme.\r\n\r\nExact requirements will depend upon the programme, but most departments will ask for a GPA of between 2.8 and 3.2/4.0.\r\n\r\n<strong>Research Degree (MPhil/PhD)</strong>\r\n\r\nIf you have Masters degree in an appropriate subject with good grades/GPA from a reputable university will be considered for entry to a Royal Holloway MPhil/PhD programme. Exact requirements will depend upon the programme, but most departments will ask for a GPA of between 3.0 and 3.2/4.0.\r\n\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n<ul id=\"majors\">\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li>Biological Sciences (MPhil/PhD)</li>\r\n \t<li>Biological Sciences Research (MSc)</li>\r\n \t<li>Accounting and Financial Management (MSc)</li>\r\n \t<li>Business and Management (MPhil/PhD)</li>\r\n \t<li>Consumption, Culture and Marketing (MA)</li>\r\n \t<li>Digital Innovation and Analytics (MSc)</li>\r\n \t<li>Digital Marketing (MSc)</li>\r\n \t<li>Entrepreneurship and Innovation (MSc)</li>\r\n \t<li>Entrepreneurship and Innovation with a Year in Business (MSc)</li>\r\n \t<li>Human Resource Management (MSc)</li>\r\n \t<li>International Management (Marketing) (MSc)</li>\r\n \t<li>International Management (MSc)</li>\r\n \t<li>Logistics and Supply Chain Management (MSc)</li>\r\n \t<li>Marketing (MA)</li>\r\n \t<li>Ancient History (MA)</li>\r\n \t<li>Classical Art and Archaeology (MA)</li>\r\n \t<li>Classical Reception (MRes)</li>\r\n \t<li>Classics (MA)</li>\r\n \t<li>Classics (MPhil/PhD)</li>\r\n \t<li>Rhetoric (MRes)</li>\r\n \t<li>Artificial Intelligence (MSc)</li>\r\n \t<li>Computational Finance (MSc)</li>\r\n \t<li>Computer Science (PhD)</li>\r\n \t<li>Computer Science by Research (MSc)</li>\r\n \t<li>Data Science and Analytics (MSc)</li>\r\n \t<li>Machine Learning (MSc)</li>\r\n \t<li>Drama by Research (MA)</li>\r\n \t<li>Drama, Theatre and Dance (MPhil/PhD)</li>\r\n \t<li>Theatre Directing (MA)</li>\r\n \t<li>Earth Sciences (MPhil/PhD)</li>\r\n \t<li>Earth Sciences by Research (MSc)</li>\r\n \t<li>Energy Geosciences (Campus-based) (MSc/PG Cert)</li>\r\n \t<li>Environmental Diagnosis and Management (MSc)</li>\r\n \t<li>Petroleum Geoscience (Distance Learning) (MSc)</li>\r\n \t<li>Computational Finance (MSc)</li>\r\n \t<li>Computational Finance (Year in Industry) (MSc)</li>\r\n \t<li>Corporate Finance (MSc)</li>\r\n \t<li>Economics \u2013 1 year (MSc)</li>\r\n \t<li>Economics \u2013 2 year (MSc)</li>\r\n \t<li>Economics (MPhil/PhD)</li>\r\n \t<li>Finance \u2013 1 year (MSc)</li>\r\n \t<li>Finance-2 year (MSc)</li>\r\n \t<li>Cyber Security Project Management (MSc)</li>\r\n \t<li>Electronic Engineering (MPhil/PhD)</li>\r\n \t<li>Electronic Engineering by Research (MSc)</li>\r\n \t<li>Engineering Management (MSc)</li>\r\n \t<li>Project Management (Distance Learning) (MSc/PGDip/PGCert)</li>\r\n \t<li>Project Management (MSc)</li>\r\n \t<li>Software Project Management (MSc)</li>\r\n \t<li>Creative Writing (MA)</li>\r\n \t<li>English (MPhil/PhD)</li>\r\n \t<li>English by Research (MA)</li>\r\n \t<li>English Literature (MA)</li>\r\n \t<li>Medieval Studies (MA)</li>\r\n \t<li>Victorian Literature, Art and Culture (MA)</li>\r\n \t<li>Cultural Geography (Research) (MRes)</li>\r\n \t<li>Geography (MPhil/PhD)</li>\r\n \t<li>Geopolitics, Development, Security and Justice (MRes)</li>\r\n \t<li>Global Futures (MSc)</li>\r\n \t<li>Global Futures: Culture and Creativity (MSc)</li>\r\n \t<li>Global Futures: Geopolitics and Security (MSc)</li>\r\n \t<li>Global Futures: Justice, Development and Sustainability (MSc)</li>\r\n \t<li>Quaternary Science (MSc/Diploma)</li>\r\n \t<li>Sustainability and Management (MSc/Diploma)</li>\r\n \t<li>Food Security, Sustainability and Biodiversity (MSc)</li>\r\n</ul>\r\n</li>\r\n</ul>\r\n<ul id=\"majors\">\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li>Global Health: Human Health and the Environment (MSc)</li>\r\n \t<li>Global Health: Society, Culture and Behaviour (MA)</li>\r\n \t<li>Health Studies (MPhil/PhD)</li>\r\n \t<li>Crusader Studies (MA)</li>\r\n \t<li>History (MA)</li>\r\n \t<li>History (MPhil/PhD)</li>\r\n \t<li>History by Research (MA)</li>\r\n \t<li>History: Gender Histories (MA)</li>\r\n \t<li>History: Hellenic Studies (MA)</li>\r\n \t<li>History: Histories of Conflict and Violence (MA)</li>\r\n \t<li>Holocaust Studies (MA)</li>\r\n \t<li>Late Antique and Byzantine Studies (MA)</li>\r\n \t<li>Medieval Studies (MA)</li>\r\n \t<li>Public History (MA)</li>\r\n \t<li>Victorian Literature, Art and Culture (MA)</li>\r\n \t<li>Information Secruity Group (MPhil/PhD)</li>\r\n \t<li>Cyber Security (Distance Learning) (MSc)</li>\r\n \t<li>Information Security (MSc/Certificate/Diploma)</li>\r\n \t<li>Information Security with a Year in Industry (MSc)</li>\r\n \t<li>Comparative Literature and Culture by Research (MA)</li>\r\n \t<li>French by Research (MA)</li>\r\n \t<li>German by Research (MA)</li>\r\n \t<li>Hispanic Studies by Research (MA)</li>\r\n \t<li>Italian by Research (MA)</li>\r\n \t<li>Languages, Literatures &amp; Cultures (MPhil/PhD)</li>\r\n \t<li>Consumption, Culture and Marketing (MA)</li>\r\n \t<li>Criminology and Criminal Justice (Distance Learning) (MSC/PGDip/PGCert)</li>\r\n \t<li>Forensic Psychology (MSc)</li>\r\n \t<li>Law and Criminology (MPhil/PhD)</li>\r\n \t<li>Psychology Law (Distance Learning) (MSc/PGDip/PGCert)</li>\r\n \t<li>Terrorism and Counter-Terrorism Studies (MSc)</li>\r\n \t<li>Mathematics (MPhil/PhD)</li>\r\n \t<li>Information Secruity (MPhil/PhD)</li>\r\n \t<li>Digital Documentary (MA)</li>\r\n \t<li>Film, Television and Digital Production by Research (MA)</li>\r\n \t<li>Immersive Storytelling (MA)</li>\r\n \t<li>International Media Management (MA)</li>\r\n \t<li>Media Arts (MPhil/PhD)</li>\r\n \t<li>Producing Film and Television (MA)</li>\r\n \t<li>Screenwriting for Television and Film (MA)</li>\r\n \t<li>Music (MMus/MMus CPD)</li>\r\n \t<li>Music (MPhil/PhD)</li>\r\n \t<li>Music Performance (PG Dip)</li>\r\n \t<li>European Philosophy (MA)</li>\r\n \t<li>Modern Philosophy (MA)</li>\r\n \t<li>Philosophy (MPhil/PhD)</li>\r\n \t<li>Philosophy by Research (MA)</li>\r\n \t<li>Political Philosophy (MA)</li>\r\n \t<li>Physics (MPhil/PhD)</li>\r\n \t<li>Physics by Research (MSc)</li>\r\n \t<li>Elections, Campaigns and Democracy (MSc)</li>\r\n \t<li>International Public Policy (MSc)</li>\r\n \t<li>International Relations (MSc)</li>\r\n \t<li>International Security (MSc)</li>\r\n \t<li>Media, Power and Public Affairs (MSc)</li>\r\n \t<li>Politics &amp; International Relations (MPhil/PhD)</li>\r\n \t<li>Politics of Development (MA)</li>\r\n \t<li>Applied Neuroscience (MSc)</li>\r\n \t<li>Applied Social Psychology (MSc)</li>\r\n \t<li>Clinical Associate Psychologist (Children and Young People) (MSc)</li>\r\n \t<li>Clinical Psychology (Doctorate)</li>\r\n \t<li>Clinical Psychology (MSc)</li>\r\n \t<li>Cognitive Behavioural Therapy (Certificate/Diploma)</li>\r\n \t<li>Psychology (MPhil/PhD)</li>\r\n \t<li>Forensic Psychology (MSc)</li>\r\n \t<li>Advanced Practice (MSc)</li>\r\n \t<li>Social Work (MPhil/PhD)</li>\r\n \t<li>Social Work (MSc)</li>\r\n \t<li>Social Work (Step up to Social Work) (Postgraduate Diploma)</li>\r\n</ul>\r\n</li>\r\n</ul>\r\n<a href=\"http://www.royalholloway.ac.uk/studying-here/\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"http://en-gb.facebook.com/royalholloway/\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"http://twitter.com/RoyalHolloway\" target=\"_blank\" rel=\"noopener\">\r\nTwitter\r\n</a>\r\n<a href=\"http://www.instagram.com/royalholloway/?hl=en\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"http://www.youtube.com/channel/UC7i5kyxBHJzo0Ziyt0nsoPQ\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.royalholloway.ac.uk/\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.royalholloway.ac.uk/studying-here/international-students/find-your-country/usa/\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.royalholloway.ac.uk/studying-here/fees-and-funding/\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.royalholloway.ac.uk/studying-here/fees-and-funding/\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.royalholloway.ac.uk/studying-here/international-students/support-for-international-students/us-student-loans/\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.royalholloway.ac.uk/studying-here/international-students/international-events/\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.royalholloway.ac.uk/research-and-teaching/\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.royalholloway.ac.uk/student-life/accommodation/\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.ravensbourne.ac.uk/information/current-staff-and-students/student-services/careers-and-industry-liaison-advice\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.su.rhul.ac.uk/opportunities/societies/\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"http://www.royalholloway.ac.uk/studying-here/applying/\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"Royal Holloway University of London","post_link":"https://theukstudyexpert.com/universities/royal-holloway/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Royal Hollway University of London\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Royal-Hollway-University-of-London-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"Egham, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10216,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"University of Southampton","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Southampton\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Southampton-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/southampton/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Southampton</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                The University of Southampton is a top 100 global university (81st; QS World University Rankings, 2024) and a founding member of the Russell Group and the Worldwide Universities Network (WUN), with over 150 years of history.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"The University of Southampton is a top 100 global university (81st; QS World University Rankings, 2024) and a founding member of the Russell Group and the Worldwide Universities Network (WUN), with over 150 years of history.","address":"University Rd, Southampton SO17 1BJ, UK","location":{"lat":"50.935742","state":"England","country":"United Kingdom","lng":"-1.3966381","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/southampton/","zoom":5,"extra_fields":{"post_excerpt":"The University of Southampton is a top 100 global university (81st; QS World University Rankings, 2024) and a founding member of the Russell Group and the Worldwide Universities Network (WUN), with over 150 years of history.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Southampton.png\" alt=\"University of Southampton\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Southampton-1.png\" alt=\"University of Southampton\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Southampton-2.png\" alt=\"University of Southampton\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Southampton-3.png\" alt=\"University of Southampton\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Southampton-4.png\" alt=\"University of Southampton\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Southampton-5.png\" alt=\"University of Southampton\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact University of Southampton\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> University Road, Southampton, Hampshire, England, SO17 1BJ, United Kingdom</p><p><strong>Website:\u00a0</strong><a href=\"https://southampton.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://southampton.ac.uk/</a></p><h3>Overview</h3><p>The University of Southampton is a campus-based university with multiple specialist campuses; although our main central campus houses the vast majority of our students, we have specialist campuses for students studying our Ocean and Earth Sciences at the National Oceanography Centre, our Humanities students studying at our Avenue Campus, our (Physical) Engineering students studying at our Boldrewood Innovation Campus, or our Art and Design students studying at our Winchester School of Art.</p><p>\u00a0</p><p>The University of Southampton is a top 100 global university (81st; QS World University Rankings, 2024) and a founding member of the Russell Group and the Worldwide Universities Network (WUN), with over 150 years of history.</p><p>\u00a0</p><p>Home to circa 25,000 students from more than 130 countries, with ca. 40% international students, Southampton prides itself on its diverse student community. As a research-intensive institution, courses are taught by world-leading academics, with access to cutting-edge facilities, and key industrial and business partnerships.</p><p>\u00a0</p><p>Southampton endeavours to develop high-value partnerships with the world\u2019s highest ranked institutions, creating a global reach in education, research and mobility that leads to real-world impact. These global partnerships create a rich international experience for our staff and students enhancing employability, citizenship, and cultural diversity.</p><p>\u00a0</p><p><strong>Population: </strong>25,000</p><p><strong>Campus Type: </strong>Urban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li><p>161 years of history, since 1862</p></li><li><p>Founding member of the Russell Group</p></li><li><p>92% of our research is world-leading or internationally excellent</p></li><li><p>Over 6,500 international students from 135 countries</p></li><li><p>Top 15 UK university and top 80 of universities worldwide</p></li></ul>\t\t\n\t\t<h3>Videos</h3>https://www.youtube.com/watch?v=3pHFI0s43OE&#038;ab_channel=UniversityofSouthamptonhttps://www.youtube.com/watch?v=_Rib-BaxvS8&#038;ab_channel=UniversityofSouthamptonhttps://www.youtube.com/watch?v=EQMpZJYPTqc&#038;ab_channel=UniversityofSouthampton\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p>To be considered for a place on one of our undergraduate (bachelors) degrees, we typically require three grades or test scores from a possible combination of AP, SAT, ACT, Grade 12 Honors Class or Grade 12 College-level class.<br /><br /></p><p>We can also consider one full year of College or a full associate degrees pending review of relevant classes taken.<br /><br /></p><ul data-rte-list=\"default\"><li><p>Minimum GPA is 3.2</p></li><li><p>Min SAT - 1300</p></li><li><p>3 AP exams with scores of 4 or 5\u2019s</p></li><li><p>ACT- 27</p></li></ul><p><br />*<strong>Students must have at least two tests demonstrating subject-specific knowledge (AP test)</strong></p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\">326 Undergraduate courses in:<li style=\"list-style-type: none;\"><ul><li>Aeronautical and astronautical engineering</li><li>Acoustical engineering</li><li>Aeronautical and astronautical engineering</li><li>Ageing and gerontology</li><li>Archaeology</li><li>Art, design and fashion</li><li>Audiology</li><li>Biological sciences</li><li>Biomedical and medical engineering</li><li>Business, accounting, finance and marketing</li><li>Chemistry and chemical engineering</li><li>Civil engineering</li><li>Computer science and software engineering</li><li>Economics</li><li>Education</li><li>Electrical and electronic engineering</li><li>English</li><li>Film studies</li><li>Geography and environmental science</li><li>History</li><li>Languages and linguistics</li><li>Law</li><li>Maritime engineering</li><li>Mathematical sciences</li><li>Mechanical engineering</li><li>Medicine</li><li>Music</li><li>Nursing, midwifery and healthcare</li><li>Ocean and Earth science</li><li>Philosophy</li><li>Photonics and optoelectronics</li><li>Physics and astronomy</li><li>Politics and international relations</li><li>Psychology</li><li>Social statistics and demography</li><li>Sociology, social policy and criminology</li></ul></li></ul>\n\t\t\t<a href=\"https://www.southampton.ac.uk/study/undergraduate\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>Bachelors degree from a recognized institution minimum GPA 3.0 out of 4 .0. However, the required GPA may vary depending on the course and educational background. For instance:</p><p>\u00a0</p><ul data-rte-list=\"default\"><li><p>UK 1st degree equivalent: GPA 3.6 out of 4.0</p></li><li><p>UK 2.1 degree equivalent: GPA 3.2 out of 4.0; GPA 3.0 from prestigious university list (complete contact form for more info).</p></li></ul>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\">219 Postgraduate Taught courses in:<li style=\"list-style-type: none;\"><ul><li>\u00a0</li><li>Aeronautical and astronautical engineering</li><li>Acoustical engineering</li><li>Aeronautical and astronautical engineering</li><li>Ageing and gerontology</li><li>Archaeology</li><li>Art, design and fashion</li><li>Audiology</li><li>Biological sciences</li><li>Biomedical and medical engineering</li><li>Business, accounting, finance and marketing</li><li>Chemistry and chemical engineering</li><li>Civil engineering</li><li>Computer science and software engineering</li><li>Economics</li><li>Education</li><li>Electrical and electronic engineering</li><li>English</li><li>Film studies</li><li>Geography and environmental science</li><li>History</li><li>Languages and linguistics</li><li>Law</li><li>Maritime engineering</li><li>Mathematical sciences</li><li>Mechanical engineering</li><li>Medicine</li><li>Music</li><li>Nursing, midwifery and healthcare</li><li>Ocean and Earth science</li><li>Philosophy</li><li>Photonics and optoelectronics</li><li>Physics and astronomy</li><li>Politics and international relations</li><li>Psychology</li><li>Social statistics and demography</li></ul></li></ul>\n\t\t\t<a href=\"https://www.southampton.ac.uk/study/postgraduate-taught\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"https://www.facebook.com/universityoflincoln/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://twitter.com/unilincoln\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.instagram.com/unilincoln/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.youtube.com/c/universityoflincoln/videos\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.southampton.ac.uk/\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.southampton.ac.uk/campaigns/usa\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.southampton.ac.uk/courses/fees/international.page\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.southampton.ac.uk/study/fees-funding/scholarships/partnerships-awards\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.southampton.ac.uk/studentservices/money-matters/student-funding/usfederalloans.page\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.southampton.ac.uk/news/events.page\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.southampton.ac.uk/research\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.southampton.ac.uk/student-life/accommodation\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.southampton.ac.uk/careers/index.page\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.susu.org/opportunities/societies\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"https://www.southampton.ac.uk/courses/how-to-apply.page\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>","post_title":"University of Southampton","post_link":"https://theukstudyexpert.com/universities/southampton/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Southampton\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Southampton-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"","city_country":"Southampton, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10212,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"University of Kent","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Kent\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Kent-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/kent/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Kent</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                The University of Kent is one of the only seven collegiate universities in the UK. Ranked world top 400 in by QS (2022) and Times Higher Education (THE 2022).\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"The University of Kent is one of the only seven collegiate universities in the UK. Ranked world top 400 in by QS (2022) and Times Higher Education (THE 2022).","address":"Giles Ln, Canterbury CT2 7NZ, UK","location":{"lat":"51.2967395","state":"England","country":"United Kingdom","lng":"1.0630042","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/kent/","zoom":5,"extra_fields":{"post_excerpt":"The University of Kent is one of the only seven collegiate universities in the UK. Ranked world top 400 in by QS (2022) and Times Higher Education (THE 2022).","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Kent.png\" alt=\"University of Kent\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Kent-1.png\" alt=\"University of Kent\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Kent-2.png\" alt=\"University of Kent\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Kent-3.png\" alt=\"University of Kent\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Kent-4.png\" alt=\"University of Kent\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Kent-5.png\" alt=\"University of Kent\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Kent-6.png\" alt=\"University of Kent\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact University of Kent\r\n</a>\r\n\r\n<strong>Location:</strong> Registry, University of Kent, Canterbury, Kent CT2 7NZ, United Kingdom\r\n\r\n<strong>Website:</strong> <a href=\"http://www.kent.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://kent.ac.uk/</a>\r\n<h3>Overview</h3>\r\nIn the\u00a0<strong>QS World </strong><strong>University Rankings 2024</strong>,\u00a0<strong>Kent\u00a0</strong>has been ranked 39th within the UK and is in the top 25% of Higher Education Institutions worldwide.\r\n\r\nKent\u00a0offers you inspiring teaching in safe and welcoming\u00a0study locations\u00a0in Canterbury and Medway as well as specialist\u00a0postgraduate centre\u00a0in\u00a0Paris<a href=\"https://www.kent.ac.uk/brussels\">.</a>\u00a0You can choose from a wide range of\u00a0foundation,\u00a0undergraduate\u00a0and\u00a0postgraduate\u00a0degrees, many of which have study abroad or year in industry options.\r\n\r\nWith a student body representing 100+ nationalities you can have fun on a global scale. Take part in Worldfest, Europe Day and celebrate events such as Holi, Thanksgiving, Chinese New year and more. You can also join our student-led international wellbeing group to meet other international students, share stories and support each other. Your\u00a0international student<u>\u00a0</u>experience will be completely unique and will equip you for every aspect of your life and career.\r\n\r\nTo support you as you expand your knowledge we have a generous scholarship fund including awards for musical and sporting excellence and dedicated scholarships for international students.\r\n\r\n<strong>Population: </strong>18,000\r\n\r\n<strong>Campus Type: </strong>Suburban\r\n<h3>Quick Facts</h3>\r\n<ul>\r\n \t<li>Two UK campuses in Canterbury (main campus) and Medway, both in the county of Kent, and a Postgraduate Study Centres in Paris</li>\r\n \t<li>Canterbury is a historic UNESCO city, only 53 mins to London and 2 hrs to Paris/Brussels</li>\r\n \t<li>One of the only seven collegiate universities in the UK.</li>\r\n \t<li>The Research Excellence Framework (REF) 2021 has confirmed Kent as a leading research university, with the majority of our submissions rated as world-leading (4*) or internationally excellent (3*).</li>\r\n \t<li>Kent Business School is accredited by AMBA, EQUIS and AACSB, the gold standard placing us among the top 1% of all business schools.</li>\r\n \t<li>Most of our programmes offer industrial placement and/or study abroad options.</li>\r\n \t<li>State-of-the-art facilities, free gym membership, affordable and high-quality accommodation.</li>\r\n \t<li>Award winning Careers Support and Service with a global approach.</li>\r\n \t<li>Personalised admissions processes treating all applicants as individuals.</li>\r\n \t<li style=\"list-style-type: none;\"></li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://www.youtube.com/watch?v=4i28Y1rbFYQhttps://www.youtube.com/watch?v=ZFNTSOnr_KAhttps://www.youtube.com/watch?v=DUwJOLzOP_ohttps://www.youtube.com/watch?v=BxsFDQLVV7Uhttps://www.youtube.com/watch?v=5edO4XhNSVQhttps://www.youtube.com/watch?v=205CBIbaZ4w\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\n<ul>\r\n \t<li>High School Graduation Diploma with a minimum final GPA of 3.2/4.0 PLUS one of the following:\r\n<ul>\r\n \t<li>SAT with a score of between 1290 \u2013 1380 depending on the subject you are applying forOR</li>\r\n \t<li>ACT with a score of between 27-29 depending on the subject you are applying forOR</li>\r\n \t<li>2 Advanced Placement (AP) tests with scores of between 4-5 depending on the subject you are applying for.</li>\r\n</ul>\r\n</li>\r\n</ul>\r\n<a href=\"https://www.kent.ac.uk/courses/undergraduate\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nFor entry to a Kent postgraduate degree programme (Master\u2019s), US students typically need to have completed a four-year undergraduate degree (Bachelor\u2019s or First Professional degree) at an accredited university or college.\r\n\r\nExact requirements will depend on the postgraduate degree you are applying for and the institution you have studied at. For programmes that require a 2:1 we usually ask for a final GPA of 3.2/4.0.\r\n\r\nStudents from highly ranked institutions may be accepted with a GPA of 3.0/4.0.\r\n\r\nFor programmes that require a 2:2 we usually ask for a final GPA of 3.0/4.0. Students from highly ranked institutions may be accepted with a GPA of 2.8/4.0.\r\n\r\n<a href=\"https://www.kent.ac.uk/courses/postgraduate\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"http://www.facebook.com/UniversityofKent\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"http://twitter.com/unikent\" target=\"_blank\" rel=\"noopener\">\r\nTwitter\r\n</a>\r\n<a href=\"http://www.instagram.com/unikentlive/\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"http://www.youtube.com/user/UniversityofKent\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.kent.ac.uk/\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.kent.ac.uk/international/countries/usa\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.kent.ac.uk/guides/tuition-fees\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.banhttps://www.kent.ac.uk/scholarshipsgor.ac.uk/international/scholarship\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.kent.ac.uk/scholarships/funding-for-american-students\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.kent.ac.uk/international\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.kent.ac.uk/courses/postgraduate/research-phd\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.kent.ac.uk/accommodation\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.kent.ac.uk/careers\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.kent.ac.uk/locations/canterbury/campus-life/social-life\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"http://www.kent.ac.uk/?utm_campaign=ukstudyexpert-usa2022&amp;utm_medium=ukstudyexpertprofile&amp;utm_source=ukstudyexpert\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"University of Kent","post_link":"https://theukstudyexpert.com/universities/kent/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Kent\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Kent-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"Canterbury, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10207,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"University of Central Lancashire","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Central Lancashire\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Central-Lancashire-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/uclan/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Central Lancashire</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                The University of Central Lancashire is an international, multi-campus as one of the UK\u2019s largest universities with over 350 undergraduate programmes.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"The University of Central Lancashire is an international, multi-campus as one of the UK\u2019s largest universities with over 350 undergraduate programmes.","address":"Fylde Rd, Preston PR1 2HE, UK","location":{"lat":"53.7645075","state":"England","country":"United Kingdom","lng":"-2.7083451","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/uclan/","zoom":5,"extra_fields":{"post_excerpt":"The University of Central Lancashire is an international, multi-campus as one of the UK\u2019s largest universities with over 350 undergraduate programmes.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Central-Lancashire.png\" alt=\"University of Central Lancashire\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Central-Lancashire-1.png\" alt=\"University of Central Lancashire\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Central-Lancashire-2.png\" alt=\"University of Central Lancashire\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Central-Lancashire-3.png\" alt=\"University of Central Lancashire\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact University of Central Lancashire\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> Preston, Lancashire, England, UK, PR1 2HE</p><p><strong>Website:</strong> <a href=\"https://uclan.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://uclan.ac.uk/</a></p><h3>Overview</h3><p>The University of Central Lancashire is an international, multi-campus University tracing its roots back to 1828 and leading the way in modern learning today. Today we\u2019re one of the UK\u2019s largest universities with a staff and student community approaching 38,000. Our employment-focused course portfolio with over 350 undergraduate programmes means we offer you the skills and experience that the industry needs. We\u2019ve always believed in helping people to seize every opportunity to flourish in education, at work and for life. Whoever you are, wherever you are in life, there\u2019s always a way. Where opportunity creates success.</p><p data-rte-preserve-empty=\"true\">\u00a0</p><p>Our institution's motto \u2018Ex solo ad solemn translates to \u2018From the Earth to the Sun\u2019. It means helping talented people from all walks of life to make the most of their potential. We create positive change in our students, staff, business partners and wider communities, enabling them to develop their full potential by providing excellent higher education, innovation and research.</p><p data-rte-preserve-empty=\"true\">\u00a0</p><p>Our community is made up of students from more than 100 countries around the world. And we are partnered with 123 institutions across the globe making us a truly international University. We are ranked in the top 7% of universities worldwide (Center for World University Rankings 2022-23). We started life in Preston and have since grown the number of our UK campuses. As well as Preston, we are also based in Burnley (East Lancashire) and Westlakes (West Cumbria). We were also honoured to establish the first British University in Cyprus in 2012.</p><p data-rte-preserve-empty=\"true\">\u00a0</p><p><strong>Population: </strong>38,000</p><p><strong>Campus Type: </strong>Urban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li><p>1828 \u2013 Founded as the \u2018Institution for the Diffusion of Knowledge\u2019. In 1992, Lancashire Polytechnic became the \u2018University of Central Lancashire\u2019 after the Government bestowed degree-awarding powers to polytechnics.</p></li><li><p>We're ranked 3rd in the UK for the mental health support we provide our students (Humen University Mental Health League Table 2022)</p></li><li><p>Preston has been named one of the best cities in the UK for graduates to live (Compare the Market 2022)</p></li><li><p>Preston is in the Top 10 Cheapest UK Cities for Student Accommodation (StudentCrowd 2022)</p></li><li><p>We guarantee a room in halls, on campus, for all new full-time students at our Preston Campus.</p></li><li><p>You'll have access to free gym membership and fitness classes at all UK campuses.</p></li><li><p>We\u2019ve spent \u00a3200 million on transforming our Preston Campus to give it a world-class makeover.</p></li><li>The most affordable University in the UK (The Times, 2023)</li></ul>\t\t\n\t\t<h3>Videos</h3>https://www.youtube.com/watch?v=l1dyIH8zOnU&#038;ab_channel=TheUniversityofCentralLancashirehttps://www.youtube.com/watch?v=Cs_spmLuAp0https://www.youtube.com/watch?v=EI_lco-qdw8\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p>Please note the requirements below are indicative only.</p><p>\u00a0</p><p>Please see the following options:</p><p>\u00a0</p><h5>Option 1 (Test Optional)</h5><p>GPA of at least 3.2 out of 4 in the High School Graduation Diploma. (A and B grades in academic college-level classes, such as advanced and honours level classes, or equivalent, and no grades below a C in Junior and Senior year).</p><p>\u00a0</p><h5>Option 2</h5><p>High School Diploma with a weighted CGPA 2.5/4.0 *1</p><p>\u00a0</p><p><strong>PLUS</strong></p><p>\u00a0</p><p>Three from below (where multiple AP's or College Credits are used, they should be for different subjects):<br /><br /></p><ul><li>SAT 1120 from \u2018Evidence Based Reading and Writing\u2019 and \u2018Math\u2019 OR ACT 22</li><li>1 AP College Board Exam at grade 3</li><li>1 AP College Board Exam at grade 3</li><li>1 AP College Board Exam at grade 3<br />College class - 3 credits at grade B from an academic class. Must be shown on college transcript.</li><li>College class - 3 credits at grade B from an academic class. Must be shown on college transcript.</li><li>College class - 3 credits at grade B from an academic class. Must be shown on college transcript.</li><li>Grade 11 or Grade 12 Honors level classes / AP classes (without the College Board Exam) grade B x 2 (two needed) (not automatically acceptable for named subject/cognate discipline requirement).<br /><br /></li></ul><h5>Option 3 (only suitable where the course has no named subject/cognate discipline requirement)</h5><p><br />High School Diploma/GED with CGPA 3.0*1</p><p>\u00a0</p><p><strong>PLUS</strong></p><p>\u00a0</p><p>ONE FROM BELOW</p><ul><li>SAT 1220 from \u2018Evidence Based Reading and Writing\u2019 and \u2018Math\u2019</li><li>ACT Composite Score 25</li></ul><h5><br />Option 4<br /><br /></h5><p>Associate diploma/Associate degree/Junior degree holders (general or specialised with 2.3/4 GPA</p><p>\u00a0</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<ul><li>Accounting &amp; Business (Foundation Entry), BA (Hons)</li><li>Accounting &amp; Business, BA (Hons)</li><li>Accounting &amp; Finance (Foundation Entry), BA (Hons)</li><li>Accounting &amp; Finance, BA (Hons)</li><li>Accounting &amp; Financial Studies (Foundation Entry), BA (Hons)</li><li>Accounting &amp; Financial Studies, BA (Hons)</li><li>Acting, BA (Hons)</li><li>Aerospace Engineering (Foundation Entry), BEng (Hons)</li><li>Aerospace Engineering (Foundation Entry), MEng (Hons)</li><li>Aerospace Engineering with Pilot Studies (Foundation Entry), BEng (Hons)</li><li>Aerospace Engineering with Pilot Studies (Foundation Entry), MEng (Hons)</li><li>Aerospace Engineering with Pilot Studies, BEng (Hons)</li><li>Aerospace Engineering with Pilot Studies, MEng (Hons)</li><li>Aerospace Engineering, BEng (Hons)</li><li>Aerospace Engineering, MEng (Hons)</li><li>Animation (Foundation Entry), BA (Hons)</li><li>Animation, BA (Hons)</li><li>Applied Biomedical Science, BSc (Hons) &#8211; Degree Apprenticeship</li><li>Applied Community &amp; Social Care Studies (Foundation Entry), BA (Hons)</li><li>Applied Community &amp; Social Care Studies, BA (Hons)</li><li>Archaeology &amp; Anthropology, BSc (Hons)</li><li>Archaeology, BSc (Hons)</li><li>Archaeology, MSci</li><li>Architectural Studies BSc (Hons) \u2013 Hong Kong</li><li>Architectural Technology, BSc (Hons) &#8211; Degree Apprenticeship</li><li>Architecture (Foundation Entry), BSc (Hons)</li><li>Architecture, BSc (Hons)</li><li>Art &amp; Design (Foundation Entry), BA (Hons)</li><li>Art, Design &amp; Media &#8211; Entry Programme</li><li>Asia Pacific Studies (Foundation Entry), BA (Hons)</li><li>Asia Pacific Studies, BA (Hons)</li><li>Assistant Practitioner, FdSc &#8211; Degree Apprenticeship</li><li>Astrobiology, Cert</li><li>Astronomy (Distance Learning), BSc (Hons)</li><li>Astronomy, Cert</li><li>Astrophysics (Foundation Entry), BSc (Hons)</li><li>Astrophysics (Foundation Entry), MPhys</li><li>Astrophysics, BSc (Hons)</li><li>Astrophysics, MPhys</li><li>Aviation &#8211; Pilot Programme, BSc (Hons) &#8211; L3Harris Airline Academy</li><li>Biology (Foundation Entry), BSc (Hons)</li><li>Biology, BSc (Hons)</li><li>Biomedical Science (Foundation Entry), BSc (Hons)</li><li>Biomedical Science, BSc (Hons)</li><li>Bioveterinary Sciences (Foundation Entry), BSc (Hons)</li><li>Bioveterinary Sciences, BSc (Hons)</li><li>British Sign Language &amp; Deaf Studies (Foundation Entry), BA (Hons)</li><li>British Sign Language &amp; Deaf Studies, BA (Hons)</li><li>Building Services &amp; Sustainable Engineering, BEng (Hons)</li><li>Building Services &amp; Sustainable Engineering, BEng (Hons) &#8211; Degree Apprenticeship</li><li>Building Surveying (Foundation Entry), BSc (Hons)</li><li>Building Surveying, BSc (Hons)</li><li>Building Surveying, BSc (Hons) &#8211; Degree Apprenticeship</li><li>Business &amp; Human Resource Management (Foundation Entry), BA (Hons)</li><li>Business &amp; Human Resource Management, BA (Hons)</li><li>Business &amp; Management (Foundation Entry), BA (Hons)</li><li>Business &amp; Management, BA (Hons)</li><li>Business &amp; Marketing (Foundation Entry), BSc (Hons)</li><li>Business &amp; Marketing, BSc (Hons)</li><li>Business Administration (Top-up), BA (Hons)</li><li>Business Management (Top-up), BA (Hons)</li><li>Business Management, BA (Hons) &#8211; Degree Apprenticeship</li><li>Business, Management, Tourism &amp; Hospitality &#8211; Entry Programme</li><li>Chemistry (Foundation Entry), BSc (Hons)</li><li>Chemistry (Foundation Entry), MChem</li><li>Chemistry, BSc (Hons)</li><li>Chemistry, MChem</li><li>Child &amp; Adolescent Mental Health Practice (Top-up), BSc (Hons)</li><li>Children Young People &amp; Families Practitioner, CertHE &#8211; Degree Apprenticeship</li><li>Children, Schools &amp; Families (Graduate Practitioner) (Top-up), BA (Hons)</li><li>Children, Schools &amp; Families (Graduate Practitioner), (Foundation Entry), BA (Hons)</li><li>Children, Schools &amp; Families (Graduate Practitioner), BA (Hons)</li><li>Civil Engineering (Foundation Entry), BEng (Hons)</li><li>Civil Engineering, BEng (Hons)</li><li>Civil Engineering, BEng (Hons) &#8211; Degree Apprenticeship</li><li>Clinical Dental Technology, BSc (Hons)</li><li>Clinical Psychology, BSc (Hons)</li><li>Community Leadership (Top-up), BA (Hons)</li><li>Computer Games Development (Foundation Entry), BSc (Hons)</li><li>Computer Games Development (Foundation Entry), MComp</li><li>Computer Games Development, BSc (Hons)</li><li>Computer Games Development, MComp</li><li>Computer Networks &amp; Security (Foundation Entry), BSc (Hons)</li><li>Computer Networks &amp; Security, BSc (Hons)</li><li>Computer Science (Foundation Entry), BSc (Hons)</li><li>Computer Science, BSc (Hons)</li><li>Computing (Foundation Entry) BSc (Hons)</li><li>Computing, BSc (Hons)</li><li>Construction Project Management (Foundation Entry), BSc (Hons)</li><li>Construction Project Management, BSc (Hons)</li><li>Cosmology, Cert</li><li>Counselling &amp; Psychotherapy, BSc (Hons)</li><li>Criminology &amp; Criminal Justice, BA (Hons)</li><li>Criminology &amp; Sociology, BA (Hons)</li><li>Cyber Security (Foundation Entry), BSc (Hons)</li><li>Cyber Security, BSc (Hons)</li><li>Dental Studies (Dental Care Professionals), BSc (Hons)</li><li>Dental Surgery, BDS</li><li>Dental Surgery, BDS &#8211; International student route</li><li>Dental Therapy, BSc (Hons)</li><li>Digital &amp; Technology Solutions, BSc (Hons) &#8211; Degree Apprenticeship</li><li>Digital Marketing, BA (Hons) &#8211; Degree Apprenticeship</li><li>Education &amp; English (Foundation Entry), BA (Hons)</li><li>Education &amp; English, BA (Hons)</li><li>Education &amp; History (Foundation Entry), BA (Hons)</li><li>Education &amp; History, BA (Hons)</li><li>Education &amp; Modern Language (Foundation Entry), BA (Hons)</li><li>Education &amp; Modern Language, BA (Hons)</li><li>Education &amp; Psychology (Foundation Entry), BA (Hons)</li><li>Education &amp; Psychology, BA (Hons)</li><li>Education &amp; Sociology (Foundation Entry), BA (Hons)</li><li>Education &amp; Sociology, BA (Hons)</li><li>Education Studies (Foundation Entry), BA (Hons)</li><li>Education Studies, BA (Hons)</li><li>Education, Philosophy &amp; Religion (Foundation Entry), BA (Hons)</li><li>Education, Philosophy &amp; Religion, BA (Hons)</li><li>Electrical &amp; Electronic Engineering (Foundation Entry), BEng (Hons)</li><li>Electrical &amp; Electronic Engineering, BEng (Hons)</li><li>Electrical &amp; Electronic Engineering, BEng (Hons) &#8211; Degree Apprenticeship</li><li>Electronic Engineering (Foundation Entry), BEng (Hons)</li><li>Electronic Engineering, BEng (Hons)</li><li>English &amp; a Modern Language (Foundation Entry), BA (Hons)</li><li>English &amp; a Modern Language, BA (Hons)</li><li>English Language &amp; Creative Writing (Foundation Entry), BA (Hons)</li><li>English Language &amp; Creative Writing, BA (Hons)</li><li>English Language &amp; Linguistics (Foundation Entry), BA (Hons)</li><li>English Language &amp; Linguistics, BA (Hons)</li><li>English Language &amp; Literature (Foundation Entry), BA (Hons)</li><li>English Language &amp; Literature, BA (Hons)</li><li>English Literature &amp; Creative Writing (Foundation Entry), BA (Hons)</li><li>English Literature &amp; Creative Writing, BA (Hons)</li><li>English Literature (Foundation Entry) BA (Hons)</li><li>English Literature, BA (Hons)</li><li>Facilities Management (Foundation Entry), BSc (Hons)</li><li>Facilities Management, BSc (Hons)</li><li>Fashion Design, BA (Hons)</li><li>Fashion Promotion &amp; Marketing, BA (Hons)</li><li>Filmmaking (Foundation Entry), BA (Hons)</li><li>Filmmaking, BA (Hons)</li><li>Fine Art, BA (Hons)</li><li>Fire &amp; Leadership Studies (Foundation Entry), BSc (Hons)</li><li>Fire &amp; Leadership Studies, BSc (Hons)</li><li>Fire Engineering (Foundation Entry), BEng</li><li>Fire Engineering (Foundation Entry), MEng</li><li>Fire Engineering, BEng (Hons)</li><li>Fire Engineering, BEng (Hons) &#8211; Degree Apprenticeship</li><li>Fire Engineering, MEng (Hons)</li><li>Fire Safety &amp; Risk Management, BSc (Hons)</li><li>Fire Safety (Engineering) (Top-up), BSc (Hons)</li><li>Fire Safety (Management) (Top-up), BSc (Hons)</li><li>Fire Safety Engineering, FdSc</li><li>Football Studies (Foundation Entry), BSc (Hons)</li><li>Football Studies, BSc (Hons)</li><li>Forensic Psychology, BSc (Hons)</li><li>Forensic Science &amp; Criminal Investigation, BSc (Hons)</li><li>Forensic Science (Foundation Entry), BSc (Hons)</li><li>Forensic Science, BSc (Hons)</li><li>Games Design (Foundation Entry), BA (Hons)</li><li>Games Design, BA (Hons)</li><li>Graduate Diploma in Law, (GDL)</li><li>Graphic Design, BA (Hons)</li><li>Health &amp; Social Care (Foundation Entry), FdA</li><li>Health &amp; Social Care (Top-up), BSc (Hons)</li><li>Health &amp; Social Care &#8211; Entry Programme</li><li>Health &amp; Social Care, FdA</li><li>Healthcare Science, BSc (Hons)</li><li>Hearing Aid Audiology, FdSc</li><li>History &amp; Politics (Foundation Entry), BA (Hons)</li><li>History &amp; Politics, BA (Hons)</li><li>History (Foundation Entry), BA (Hons)</li><li>History, BA (Hons)</li><li>Illustration, BA (Hons)</li><li>Interior Design, BA (Hons)</li><li>International Business (Foundation Entry), BA (Hons)</li><li>International Business Communication with Modern Foreign Language, BA (Hons)</li><li>International Business Communication, BA (Hons)</li><li>International Business, BA (Hons)</li><li>International Hospitality Management (Foundation Entry), BA (Hons)</li><li>International Hospitality Management, BA (Hons)</li><li>International Journalism (Foundation Entry), BA (Hons)</li><li>International Journalism, BA (Hons)</li><li>International Relations (Foundation Entry), BA (Hons)</li><li>International Relations, BA (Hons)</li><li>International Tourism Management (Foundation Entry), BA (Hons)</li><li>International Tourism Management, BA (Hons)</li><li>Journalism (Foundation Entry), BA (Hons)</li><li>Journalism, BA (Hons)</li><li>Law (Foundation Entry), LLB (Hons)</li><li>Law with Business, LLB (Hons)</li><li>Law with Criminology, LLB (Hons)</li><li>Law, Criminology, Policing &amp; Sociology &#8211; Return to Study</li><li>Law, LLB (Hons)</li><li>Legal Practice, LLB (Hons) &#8211; Degree Apprenticeship</li><li>Management in Events (Top-up), BA (Hons)</li><li>Management in Hospitality (Top-up), BA (Hons)</li><li>Management in Tourism (Top-up), BA (Hons)</li><li>Manufacturing Engineering (Foundation Entry), BEng (Hons)</li><li>Manufacturing Engineering, BEng (Hons)</li><li>Manufacturing Engineering, BEng (Hons) &#8211; Degree Apprenticeship</li><li>Mathematical Physics, BSc (Hons)</li><li>Mathematical Physics, MPhys</li><li>Mathematics (Foundation Entry), BSc (Hons)</li><li>Mathematics, BSc (Hons)</li><li>Mechanical Engineering (Foundation Entry), BEng (Hons)</li><li>Mechanical Engineering (Foundation Entry), MEng (Hons)</li><li>Mechanical Engineering, BEng (Hons)</li><li>Mechanical Engineering, BEng (Hons) &#8211; Degree Apprenticeship</li><li>Mechanical Engineering, MEng (Hons)</li><li>Mechanical Maintenance Engineering (Top-up), BEng (Hons)</li><li>Mechatronics &amp; Intelligent Machines (Top-up), BEng (Hons)</li><li>Mechatronics &amp; Intelligent Machines, BEng (Hons)</li><li>Mechatronics &amp; Intelligent Machines, BEng (Hons) &#8211; Degree Apprenticeship</li><li>Media &amp; Television Production (Foundation Entry), BA (Hons)</li><li>Media &amp; Television Production, BA (Hons)</li><li>Medical Sciences (Foundation Entry), BSc (Hons)</li><li>Medical Sciences, BSc (Hons)</li><li>Medicine &amp; Surgery (Foundation Entry), MBBS</li><li>Medicine &amp; Surgery, MBBS</li><li>Mental Health &amp; Wellbeing Coaching, BSc (Hons)</li><li>Microbiology (Foundation Entry), BSc (Hons)</li><li>Microbiology, BSc (Hons)</li><li>Midwifery (Shortened), BSc (Hons)</li><li>Midwifery, BSc (Hons)</li><li>Modern Languages (Foundation Entry), BA (Hons)</li><li>Modern Languages, BA (Hons)</li><li>Motorsports Engineering (Foundation Entry), BEng (Hons)</li><li>Motorsports Engineering (Foundation Entry), MEng (Hons)</li><li>Motorsports Engineering, BEng (Hons)</li><li>Motorsports Engineering, MEng (Hons)</li><li>Music Theatre, BA (Hons)</li><li>Neuropsychology, BSc (Hons)</li><li>Neuroscience (Foundation Entry), BSc (Hons)</li><li>Neuroscience, BSc (Hons)</li><li>Nursing (Top-up), BSc (Hons)</li><li>Nursing Associate, FdSc &#8211; Degree Apprenticeship</li><li>Nursing in General Practice (Top-up), BSc (Hons)</li><li>Nursing with Registered Nurse (Adult) &#8211; Degree Apprenticeship, BSc (Hons)</li><li>Nursing with Registered Nurse (Adult), BSc (Hons)</li><li>Nursing with Registered Nurse (Adult), BSc (Hons) &#8211; Practice Based Pathway</li><li>Nursing with Registered Nurse (Children &amp; Young People), BSc (Hons)</li><li>Nursing with Registered Nurse (Children &amp; Young People), BSc (Hons) &#8211; Degree Apprenticeship</li><li>Nursing with Registered Nurse (Learning Disabilities), BSc (Hons)</li><li>Nursing with Registered Nurse (Mental Health), BSc (Hons)</li><li>Nursing with Registered Nurse (Mental Health), BSc (Hons) &#8211; Degree Apprenticeship</li><li>Nutrition &amp; Exercise Sciences (Foundation Entry), BSc (Hons)</li><li>Nutrition &amp; Exercise Sciences, BSc (Hons)</li><li>Occupational Therapy, BSc (Hons)</li><li>Oil &amp; Gas Safety Engineering, BEng (Hons)</li><li>Operating Department Practice, BSc (Hons)</li><li>Operating Department Practice, BSc (Hons) &#8211; Degree Apprenticeship</li><li>Ophthalmic Dispensing, BSc (Hons)</li><li>Outdoor Adventure Leadership (Foundation Entry), BA (Hons)</li><li>Outdoor Adventure Leadership, BA (Hons)</li><li>Paramedic Science, BSc (Hons)</li><li>Pharmacology (Foundation Entry), BSc (Hons)</li><li>Pharmacology, BSc (Hons)</li><li>Pharmacy, MPharm (Hons)</li><li>Photography, BA (Hons)</li><li>Physician Associate Studies, MPAS (Hons)</li><li>Physics (Foundation Entry), BSc (Hons)</li><li>Physics (Foundation Entry), MPhys</li><li>Physics with Astrophysics (Foundation Entry), BSc (Hons)</li><li>Physics with Astrophysics (Foundation Entry), MPhys</li><li>Physics with Astrophysics, BSc (Hons)</li><li>Physics with Astrophysics, MPhys</li><li>Physics, BSc (Hons)</li><li>Physics, MPhys</li><li>Physiology &amp; Pharmacology (Foundation Entry), BSc (Hons)</li><li>Physiology &amp; Pharmacology, BSc (Hons)</li><li>Physiotherapy, BSc (Hons)</li><li>Physiotherapy, BSc (Hons) &#8211; Degree Apprenticeship</li><li>Policing, Law Enforcement &amp; Investigation (Foundation Entry), BSc (Hons)</li><li>Policing, Law Enforcement &amp; Investigation, BSc (Hons)</li><li>Professional Policing (Foundation Entry), BSc (Hons)</li><li>Professional Policing Practice, BSc (Hons) &#8211; Degree Apprenticeship</li><li>Professional Policing, BSc (Hons)</li><li>Professional Practice (Top-up), BSc (Hons)</li><li>Psychological Wellbeing Practitioners, BSc (Hons)</li><li>Psychology &amp; Criminology, BSc (Hons)</li><li>Psychology (Foundation Entry), BSc (Hons)</li><li>Psychology of Child Development, BSc (Hons)</li><li>Psychology with Psychotherapy &amp; Counselling (Foundation Entry), BSc (Hons)</li><li>Psychology with Psychotherapy &amp; Counselling, BSc (Hons)</li><li>Psychology, BSc (Hons)</li><li>Public Services (Top-up), BA (Hons)</li><li>Quantity Surveying (Foundation Entry), BSc (Hons)</li><li>Quantity Surveying, BSc (Hons)</li><li>Quantity Surveying, BSc (Hons) &#8211; Degree Apprenticeship</li><li>Religion, Culture &amp; Society (Foundation Entry), BA (Hons)</li><li>Religion, Culture &amp; Society, BA (Hons)</li><li>Robotics Engineering (Foundation Entry), BEng (Hons)</li><li>Robotics Engineering, BEng (Hons)</li><li>Screenwriting with Film, Television &amp; Radio, BA (Hons)</li><li>Screenwriting with Film, TV &amp; Radio (Foundation Entry), BA (Hons)</li><li>Sexual Health (Foundation Entry), BSc (Hons)</li><li>Sexual Health, BSc (Hons)</li><li>Social Work, BA (Hons)</li><li>Social Work, BA (Hons) &#8211; Degree Apprenticeship</li><li>Sociology, BA (Hons)</li><li>Software Engineering (Foundation Entry), BSc (Hons)</li><li>Software Engineering, BEng &#8211; Degree Apprenticeship</li><li>Software Engineering, BSc (Hons)</li><li>Software Engineering, FdSc</li><li>Sport &amp; Exercise Science (Foundation Entry), BSc (Hons)</li><li>Sport &amp; Exercise Science, BSc (Hons)</li><li>Sport &amp; Physical Education (Foundation Entry), BA (Hons)</li><li>Sport &amp; Physical Education, BA (Hons)</li><li>Sport &#8211; Entry Programme</li><li>Sport Business Management (Foundation Entry), BSc (Hons)</li><li>Sport Business Management, BSc (Hons)</li><li>Sports Coaching &amp; Development (Foundation Entry), BA (Hons)</li><li>Sports Coaching &amp; Development, BA (Hons)</li><li>Sports Coaching &amp; Performance (Foundation Entry), BSc (Hons)</li><li>Sports Coaching &amp; Performance, BSc (Hons)</li><li>Sports Journalism (Foundation Entry), BA (Hons)</li><li>Sports Journalism, BA (Hons)</li><li>Sports Therapy (Foundation Entry), BSc (Hons)</li><li>Sports Therapy, BSc (Hons)</li><li>Sun, Earth &amp; Climate, Cert</li><li>Teaching English to Speakers of Other Languages &amp; Modern Language (Foundation Entry), BA (Hons)</li><li>Teaching English to Speakers of Other Languages (TESOL) &amp; Modern Language, BA (Hons)</li><li>Textile Design, BA (Hons)</li><li>Theatre &amp; Performance, BA (Hons)</li><li>Veterinary Medicine &amp; Surgery (Foundation Entry), BVMS</li><li>Veterinary Medicine &amp; Surgery, BVMS</li><li>Youth Work &amp; Community Practice (Foundation Entry), BA (Hons)</li><li>Youth Work &amp; Community Practice, BA (Hons)</li></ul>\n\t\t\t<a href=\"https://www.uclan.ac.uk/courses/a-z/undergraduate\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>Please note the requirements below are indicative only Bachelor\u2019s Degree from reputable university:</p><ul data-rte-list=\"default\"><li><p>GPA 2.4/4.0 = 2:2</p></li><li><p>GPA 3.0/4.0 = 2:1</p></li></ul>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<ul><li>Additive Manufacturing, MSc</li><li>Advanced Clinical Practitioner, MSc &#8211; Degree Apprenticeship</li><li>Advanced Pharmacy Practice, MSc/PGDip</li><li>Animation, MA</li><li>Applied Clinical Psychology, MSc</li><li>Applied Data Science, MSc</li><li>Applied Forensic Psychology, MSc</li><li>Applied Public Health, MSc</li><li>Applied Public Health, PGCert</li><li>Applied Public Health, PGDip</li><li>Architecture (Part II), MArch</li><li>Associate Psychological Practitioner, PGCert</li><li>British Sign Language/English Interpreting, PGDip/MA</li><li>Building Conservation &amp; Adaptation, MSc/PGDip/PGCert</li><li>Business Administration (Executive), PGDip &#8211; Degree Apprenticeship</li><li>Business Administration with Professional Placement, MBA</li><li>Cancer Biology &amp; Therapy, MSc</li><li>Cancer Biology, MRes</li><li>Ceramics, MA</li><li>Child &amp; Adolescent Mental Health, MSc</li><li>Children&#8217;s Book Illustration, MA</li><li>Clinical Community Nursing, PGCert</li><li>Clinical Implantology, MSc</li><li>Clinical Periodontology, MSc</li><li>Clinical Practice, Management &amp; Education, MSc/PGDip/PGCert</li><li>Cognitive Behavioural Psychotherapy, MSc</li><li>Community Health Practice, MSc</li><li>Community Specialist Practitioner, PGDip</li><li>Computing, MSc</li><li>Construction Project Management, MSc</li><li>Counter Terrorism, MSc</li><li>Criminal Investigation, MSc</li><li>Criminal Justice, MSc</li><li>Criminology, MA</li><li>Cybercrime Investigation, MSc</li><li>Dental Education, MSc</li><li>Dietetics (Pre-registration), MSc</li><li>Digital Health, MSc</li><li>Digital Marketing Communications, MSc</li><li>Disaster Medicine, MSc</li><li>District Nursing with Integrated Independent Prescribing, PGDip &#8211; Degree Apprenticeship</li><li>DNA Profiling, MSc</li><li>Drug Discovery &amp; Development, MSc</li><li>Education &amp; Training, PGCE</li><li>Elite Coaching Practice, MSc</li><li>Elite Performance, MProf</li><li>Emergency Management in High Hazard Industries, MSc</li><li>Emergency Medicine Point of Care Ultrasound, Short Course</li><li>Endodontology, MSc</li><li>Facilitating Learning in Healthcare Practice, Cert</li><li>Facilities Management, MSc</li><li>Fashion &amp; Lifestyle Promotion, MA</li><li>Fashion Design, MA</li><li>Financial Investigation, MSc</li><li>Financial Management, MSc</li><li>Fine Art, MA</li><li>Fire Safety Engineering, MSc</li><li>Fire Scene Investigation, MSc</li><li>Football Medical Leadership &amp; Performance, MSc</li><li>Football Science &amp; Rehabilitation, MSc</li><li>Forensic Science &amp; Crime Scene Investigation, MSc</li><li>Games Design, MA</li><li>Graphic Design, MA</li><li>Health Informatics, MSc</li><li>Health Informatics, PGCert</li><li>Health Informatics, PGDip</li><li>Healthcare Practice, MSc</li><li>History, MRes</li><li>Human Resource Management, MA</li><li>Human Resource Management, MSc</li><li>Human Resource Management, PGDip</li><li>Industrial Pharmaceutics, MSc</li><li>Injection Therapy, Cert</li><li>Integrative Psychotherapy, PGDip/MA</li><li>Intelligent Maintenance Engineering, MSc</li><li>Intercultural Business Communication, MA</li><li>Interior Design, MA</li><li>International Business &amp; Management, MSc</li><li>International Business Law, LLM</li><li>International Hospitality &amp; Event Management, MSc</li><li>International Hospitality &amp; Tourism Management, MSc</li><li>International Medical Sciences, PGDip</li><li>International Relations, MA</li><li>International Social Work &amp; Community Development, MA</li><li>Internship in International Tourism, Hospitality &amp; Event Management, MA</li><li>Interpreting &amp; Translation, MA</li><li>Investigating Serious Incidents, PGCert</li><li>IT Security, MSc</li><li>Journalism Innovation &amp; Leadership, MA/PGCert</li><li>Law, LLM</li><li>Legal Practice, LLM</li><li>Legal Practice, MProf &#8211; Degree Apprenticeship</li><li>Maintenance Engineering, MSc</li><li>Management, MRes</li><li>Mechanical Engineering, MSc</li><li>Mechatronics &amp; Intelligent Machines, MSc</li><li>Medical Education, MSc/PGDip/PGCert</li><li>Medical Leadership, MSc</li><li>Medical Sciences, MRes</li><li>Mental Health Practice, PGCert</li><li>Mentoring in Dental Practice, AdvCert</li><li>Midwifery (Shortened), MSc</li><li>Midwifery, MSc</li><li>Mountain Medicine, MSc/PGDip</li><li>Musculoskeletal Management, MSc</li><li>Music Industry Management &amp; Promotion, MA</li><li>Nanoscience &amp; Nanotechnology, MSc</li><li>Neuroscience, MRes</li><li>North Korean Studies, MA</li><li>Nursing in General Practice, MSc</li><li>Nursing with Registered Nurse (Adult), MSc</li><li>Nursing with Registered Nurse (Mental Health), MSc</li><li>Nursing, MSc</li><li>Nutrition &amp; Exercise Sciences, MSc</li><li>Occupational Therapy (Pre-registration), MSc</li><li>Oil &amp; Gas Engineering, MSc</li><li>Optometry, MSc</li><li>Oral Surgery, MSc</li><li>Outdoor Practice, MA</li><li>Performance Analysis &amp; Talent Management, MSc</li><li>Person Centred Experiential Counselling for Depression, AdvCert</li><li>Personality Disorder (Practice Development), MSc</li><li>Personality Disorder (Research), MSc</li><li>Philosophy &amp; Mental Health, MA</li><li>Photography, MA</li><li>Physical Education &amp; School Sport, MA</li><li>Physician Associate Practice, MSc</li><li>Physiotherapy (Pre-registration), MSc</li><li>Professional Development &amp; Practice, PGCert</li><li>Professional Practice in Education, MEd</li><li>Professional Practice with Children &amp; Young People, MA</li><li>Project Management, MSc</li><li>Promoting Psychological Wellbeing (IAPT), PGCert</li><li>Prosthodontics, MSc</li><li>Psychology Conversion, MSc</li><li>Psychology of Child Development, MSc</li><li>Publishing, MA</li><li>Religion, Culture &amp; Society, MA</li><li>Remote &amp; Rural Medicine, MSc/PGDip/PGCert</li><li>Renewable Energy Engineering, MSc</li><li>Safeguarding Children, PGCert</li><li>Safeguarding in an International Context, MSc</li><li>Scriptwriting, MA</li><li>Social Policy, MA</li><li>Social Work, MA</li><li>Specialist Community Public Health Nurse, PGDip</li><li>Speech &amp; Language Therapy (Pre-registration), MSc</li><li>Sport &amp; Exercise Science, MSc</li><li>Sport Business Management, MSc</li><li>Sport Coach Developer, MSc</li><li>Sports Coaching, MSc</li><li>Sports Medicine, MSc</li><li>Strength &amp; Conditioning, MSc</li><li>Supply Chain Management, MSc</li><li>Surface Pattern &amp; Textiles, MA</li><li>Sustainability, Health &amp; Wellbeing, MSc</li><li>Teaching English to Speakers of Other Languages (TESOL) with Applied Linguistics, MA</li><li>Teaching English to Speakers of Other Languages (TESOL), MA</li><li>Television Production, MA</li><li>Therapeutic Work with Children &amp; Adolescents, Cert</li><li>Urgent Care, MSc</li><li>Urgent Medical Care, Cert</li><li>User Experience (UX) Design, MSc</li><li>Veterinary Physiotherapy &amp; Clinical Rehabilitation, MSc</li></ul>\n\t\t\t<a href=\"http://www.uclan.ac.uk/courses/a-z/postgraduate-taught\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"https://www.facebook.com/universityoflincoln/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://twitter.com/unilincoln\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.instagram.com/unilincoln/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.youtube.com/c/universityoflincoln/videos\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.uclan.ac.uk/\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.uclan.ac.uk/international-students/country/united-states-of-america\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.uclan.ac.uk/study/fees-and-finance/bursaries-and-scholarships\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.uclan.ac.uk/study/fees-and-finance/bursaries-and-scholarships\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.uclan.ac.uk/study/fees-and-finance/eu-and-international-students/us-loans\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"http://www.uclan.ac.uk/events\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"http://www.uclan.ac.uk/research\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.uclan.ac.uk/accommodation\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.uclan.ac.uk/support/careers\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.uclansu.co.uk/\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"http://www.uclan.ac.uk/international-students/how-to-apply\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"University of Central Lancashire","post_link":"https://theukstudyexpert.com/universities/uclan/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Central Lancashire\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Central-Lancashire-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"","city_country":"Preston, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10200,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"BIMM University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"BIMM University\" width=\"300\" height=\"225\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/BIMM-Uni-1-300x225.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/bimm/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">BIMM University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                At BIMM University we provide an extensive range of courses in modern music, performing arts, and filmmaking to over 9,000 students across 15 campuses and colleges in the UK, Germany and Ireland.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"At BIMM University we provide an extensive range of courses in modern music, performing arts, and filmmaking to over 9,000 students across 15 campuses and colleges in the UK, Germany and Ireland.","address":"38-42 Brunswick St W, Brighton and Hove, Hove BN3 1EL, UK","location":{"lat":"50.8248993","city":"Brighton and Hove","state":"England","country":"United Kingdom","lng":"-0.1603376","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/bimm/","zoom":5,"extra_fields":{"post_excerpt":"At BIMM University we provide an extensive range of courses in modern music, performing arts, and filmmaking to over 9,000 students across 15 campuses and colleges in the UK, Germany and Ireland.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/BIMM.png\" alt=\"BIMM University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/BIMM-1.png\" alt=\"BIMM University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/BIMM-2.png\" alt=\"BIMM University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/BIMM-3.png\" alt=\"BIMM University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/BIMM-4.png\" alt=\"BIMM University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/BIMM-5.png\" alt=\"BIMM University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/BIMM-6.png\" alt=\"BIMM University\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/BIMM-7.png\" alt=\"BIMM University\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact BIMM University\r\n</a>\r\n\r\n<strong>Location:</strong> 38-42 Brunswick Street West, Hove, East Sussex, BN3 1EL, United Kingdom\r\n\r\n<strong>Website:</strong> <a href=\"https://www.bimm.university/\" target=\"_blank\" rel=\"noopener\">https://bimm.university</a>\r\n<h3>Overview</h3>\r\nBIMM University is a world-renowned creative arts institution that fosters talent across music, film, performing arts, and creative technologies. With nine campuses in the UK, Ireland, and Germany, including Berlin, we offer a diverse range of English-taught bachelor\u2019s, CertHE, and master\u2019s programmes.\u00a0Our institution is made up of four specialist schools: BIMM Music Institute, with over 40 years of contemporary music education experience; MetFilm School, a hub for budding filmmakers; MetStudios, focused on innovation in games, animation, and VFX; and Performers College, which delivers training in dance, musical theatre, and acting. Together, they reflect the collaborative and interconnected nature of today\u2019s creative industries.\u00a0Our lecturers are industry professionals, and we teach with state-of-the-art tools and technology, ensuring students graduate with the skills, experience, and confidence to succeed. With 10,000 students representing over 60 nationalities, BIMM University is a global creative hub, empowering the next generation to shape the future of their industries.\r\n\r\n<strong>Population: </strong>9,000\r\n\r\n<strong>Campus Type: </strong>Urban\r\n<h3>Quick Facts</h3>\r\n<ul data-rte-list=\"default\">\r\n \t<li>Leading creative arts education provider with 9,000 students across the UK, Germany and Ireland</li>\r\n \t<li>Multiple creative city locations with options for undergraduates to transfer after each year of study</li>\r\n \t<li>Cutting-edge equipment and facilities</li>\r\n \t<li>Industry-led courses that are practical and vocational in nature</li>\r\n \t<li>World-class lecturers that are all active in the industry offering small class sizes and personal tutoring</li>\r\n \t<li>Frequent masterclasses and workshops from industry experts and trailblazers</li>\r\n \t<li>Alumni success from world renowned artists, record label executives, journalists, producers, songwriters, directors, actors and choreographers</li>\r\n \t<li>Networking opportunities and mentoring as well as internships and placements.</li>\r\n \t<li>In-house recruitment agency linking students with nearly 1,000 employers across the creative industries</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://www.youtube.com/watch?v=xYCUDt9G_OMhttps://www.youtube.com/watch?v=LK8Dr5WzOlghttps://www.youtube.com/watch?v=uVfaSDmP6Pc\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nHigh School Diploma with 2.5-2.8+.\r\nSAT, AP or ACT test scores can also be considered.\r\nMost courses require a successful audition, interview or portfolio review.\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n\r\nDegree &amp; Location\r\n<ul>\r\n \t<li>BMus (Hons) Popular Music Performance- Berlin, Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BMus (Hons) Songwriting \u2013 Berlin, Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BA (Hons) Music &amp; Sound Production \u2013 Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BA (Hons) Electronic Music Production \u2013 Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BA (Hons) Music Production \u2013 Berlin</li>\r\n \t<li>BA (Hons) Commercial Modern Music \u2013 Dublin</li>\r\n \t<li>BA (Hons) Music Marketing, Media &amp; Communication \u2013 Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BA (Hons) Event Management \u2013 Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BA (Hons) Music Business \u2013 Berlin, Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BA (Hons) Music Business &amp; Event Management \u2013 Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BA (Hons) Music Production &amp; Music Business \u2013 Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BA (Hons) Popular Music Performance &amp; Event Management \u2013 Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BA (Hons) Popular Music Performance &amp; Music Business \u2013 Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BA (Hons) Popular Music Performance &amp; Music Production \u2013 Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BMus (Hons) Popular Music Performance &amp; Songwriting \u2013 Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BA (Hons) Songwriting &amp; Music Business \u2013 Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BA (Hons) Songwriting &amp; Music Production \u2013 Birmingham, Brighton, Bristol, London, Manchester</li>\r\n \t<li>BA (Hons) Filmmaking \u2013 Birmingham, Brighton, Manchester, Berlin</li>\r\n \t<li>BA (Hons) Filmmaking (Top Up) \u2013 Birmingham, Brighton, Manchester</li>\r\n \t<li>BA (Hons) Production Design for Screen and Film \u2013 Brighton</li>\r\n \t<li>BA (Hons) Hair and Make Up for Screen and Film \u2013 Brighton</li>\r\n \t<li>BA (Hons) Film Business and Production \u2013 Brighton, Manchester</li>\r\n \t<li>BA (Hons) Performing Arts \u2013 Brighton, Manchester</li>\r\n \t<li>BA (Hons) Performing Arts (Top Up) \u2013 Brighton, Manchester</li>\r\n \t<li>BA (Hons) Musical Theatre and Dance \u2013 Birmingham, Essex</li>\r\n \t<li>BA (Hons) Acting for Stage, Screen and Digital Media \u2013 Birmingham, Essex, Berlin</li>\r\n</ul>\r\n<a href=\"https://www.bimm.ac.uk/course-finder/\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<a href=\"https://www.bimm.university/schools/?utm_source=referral&amp;utm_medium=web&amp;utm_campaign=UKSE\">\r\nOur Schools\r\n</a>\r\n<a href=\"https://www.bimm.ac.uk/course-finder/\">\r\nBIMM Institute UG\r\n</a>\r\n<a href=\"https://www.metfilmschool.ac.uk/study-with-us/undergraduate-courses/\">\r\nMetFilm School UG\r\n</a>\r\n<a href=\"https://performerscollege.co.uk/course-finder/?courselevel=degree&amp;coursearea=&amp;location=\">\r\nPerformers College UG\r\n</a>\r\n<a href=\"https://www.metfilmschool.ac.uk/courses/undergraduate/\">\r\nMetStudios UG\r\n</a>\r\n<a href=\"https://www.bimm-institute.de/course-finder/\">\r\nBIMM University Berlin UG\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<figure id=\"yui_3_17_2_1_1687973475616_248\" data-scrolled=\"\" data-test=\"image-block-v2-outer-wrapper\"><figcaption data-width-ratio=\"\">\r\n<h4>US Entry Requirements</h4>\r\nFour-year bachelor degree with a minimum GPA of 2.4.\r\n\r\nMost courses require a successful audition, interview or portfolio review.\r\n\r\n</figcaption></figure>\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n\r\nDegree &amp; Location\r\n<ul>\r\n \t<li>MA Learning &amp; Teaching in the Creative Industries \u2013 Brighton, Bristol</li>\r\n \t<li>MA Popular Music Practice \u2013 Berlin, Birmingham, Brighton, Bristol, Dublin, London, Manchester</li>\r\n \t<li>MA Screen and Film Production \u2013 Birmingham, Brighton</li>\r\n \t<li>MA Performing Arts*- Essex</li>\r\n</ul>\r\n<a href=\"https://www.bimm.ac.uk/postgraduate/\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<a href=\"https://www.bimm.ac.uk/postgraduate/\">\r\nBIMM Institute PG\r\n</a>\r\n<a href=\"https://www.metfilmschool.ac.uk/study-with-us/postgraduate-courses/\">\r\nMetFilm School PG\r\n</a>\r\n<a href=\"https://performerscollege.co.uk/postgraduate/\">\r\nPerformers College PG\r\n</a>\r\n<a href=\"https://www.metfilmschool.ac.uk/courses/postgraduate/\">\r\nMetStudios PG\r\n</a>\r\n<a href=\"https://www.bimm-institute.de/postgraduate/\">\r\nBIMM University Berlin PG\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/BIMMInstitute/\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://twitter.com/bimm_institute?lang=en\" target=\"_blank\" rel=\"noopener\">\r\nTwitter\r\n</a>\r\n<a href=\"https://www.instagram.com/bimm_stagram/?hl=en\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/channel/UCmA64TnsaDBwd11EcOZKkCQ\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.bimm.university/\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.bimm.ac.uk/international/\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.bimm.ac.uk/international/fees-finance/\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.bimm.ac.uk/international/fees-finance/\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li>FAFSA - does not accept FAFSA funding</li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.bimm.ac.uk/open-days/\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.bimm.university/governance-and-quality/academic-research/\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.bimm.ac.uk/accommodation/\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.bimm.ac.uk/employability/\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.bangor.ac.uk/student-life/clubs_societies\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"https://www.bimm.ac.uk/apply/\">\r\nAPPLY to BIMM INSTITUTE\r\n</a>\r\n<a href=\"https://www.metfilmschool.ac.uk/apply/\">\r\nAPPLY to METFILM SCHOOL\r\n</a>\r\n<a href=\"https://performerscollege.co.uk/apply/\">\r\nAPPLY to PERFORMERS COLLEGE\r\n</a>\r\n<a href=\"https://www.metfilmschool.ac.uk/apply/\">\r\nAPPLY to METSTUDIOS\r\n</a>\r\n<a href=\"https://www.bimm-institute.de/apply/\">\r\nAPPLY to BIMM UNIVERSITY BERLIN\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"BIMM University","post_link":"https://theukstudyexpert.com/universities/bimm/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"BIMM University\" width=\"300\" height=\"225\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/BIMM-Uni-1-300x225.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.4-2.59, 2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, England, Humanities, Northern Ireland, Technology Computer Science","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"2.4-2.59, 2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, England, Humanities, Northern Ireland, Technology Computer Science","city_country":"Brighton, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10198,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"University of Glasgow","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Glasgow\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Glasgow-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/glasgow/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Glasgow</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Over the last five centuries, the University of Glasgow has fostered the talents of seven Nobel laureates, one Prime Minister, and Scotland\u2019s inaugural First Minister.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Over the last five centuries, the University of Glasgow has fostered the talents of seven Nobel laureates, one Prime Minister, and Scotland\u2019s inaugural First Minister.","address":"Glasgow G12 8QQ, UK","location":{"lat":"55.87242560000001","state":"Scotland","country":"United Kingdom","lng":"-4.2900009","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/glasgow/","zoom":5,"extra_fields":{"post_excerpt":"Over the last five centuries, the University of Glasgow has fostered the talents of seven Nobel laureates, one Prime Minister, and Scotland\u2019s inaugural First Minister.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Glasgow.png\" alt=\"University of Glasgow\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Glasgow-1.png\" alt=\"University of Glasgow\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact University of Glasgow\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> Glasgow G12 8QQ, United Kingdom</p><p><strong>Website:</strong> <a href=\"https://www.gla.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://glas.ac.uk/</a></p><h3>Overview</h3><p>Over the last five centuries, the University of Glasgow has pushed the boundaries of possibility. We\u2019ve fostered the talents of seven Nobel laureates, one Prime Minister, and Scotland\u2019s inaugural First Minister. We have always been at the forefront of innovation, and our past achievements inspire our current world changers.</p><p>\u00a0</p><p>With more than 33,000 students, the University is a melting pot of ideas, ingenuity and innovation. It is housed in one of the most stunning campuses in the UK and in a city that matches the University in dynamism and vibrancy. We know we offer a unique student experience and we welcome you to find out for yourself.</p><p>\u00a0</p><p><strong>Population: </strong>33,000</p><p><strong>Campus Type: </strong>Urban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li><p>Founded in 1451, we are the fourth oldest university in the English-speaking world.</p></li><li><p>Circa 33,000 undergraduate and postgraduate students for 140 Countries, Strategic partnerships with the Universities of Columbia, Hong Kong, McGill and Sydney.</p></li><li><p>Included in the Top 100 Universities in the World - Times Higher World University Rankings 2021.</p></li><li><p>Currently undertaking a \u00a31 billion estate investment to expand campus research &amp; teaching facilities.</p></li><li><p>Among its alumni include the father of economics Adam Smith, Scotland\u2019s architect of devolution Donald Dewar and renowned physicist and engineer Lord Kelvin.</p></li></ul>\t\t\n\t\t<h3>Videos</h3>https://www.youtube.com/watch?v=R89_88woscQhttps://www.youtube.com/watch?v=c9jG88DrpYshttps://www.youtube.com/watch?v=tlbBATI0rDI&#038;list=PLZg7vx6J9i0LOM-Ztl-TJN66_aVpK4Uxfhttps://www.youtube.com/watch?list=PLZg7vx6J9i0LOwTheVG7PB3tuafTeauKN&#038;v=z28c5hWBbsE\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p>The University of Glasgow offers multiple pathways for U.S. students to meet entry requirements, combining high school GPA, AP exams, SAT/ACT scores, and other qualifications.</p><hr /><h4><strong>Minimum Academic Requirements</strong></h4><ol><li><p><strong>Advanced Placement (AP):</strong></p><ul><li>AAA = 555 on three AP exams.</li><li>AAB = 554, ABB = 544, BBB = 444.</li></ul></li><li><p><strong>SAT:</strong></p><ul><li>1280 SAT + Honours/Advanced/AP level course in Year 11 or 12 at A in mandatory subject requirements.</li></ul></li><li><p><strong>ACT:</strong></p><ul><li>27 ACT + Honours/Advanced/AP level course in Year 11 or 12 at A in mandatory subject requirements.</li></ul></li><li><p><strong>High School GPA:</strong></p><ul><li>A*AA = 3.7 GPA; AAA = 3.6; AAB = 3.5; ABB = 3.4; BBB = 3.3.</li><li>Must be combined with Honors, AP, or IB level.</li></ul></li><li><p><strong>Associate Degree:</strong></p><ul><li>A*AA/AAA = GPA of 3.0; AAB = 2.9; ABB = 2.8; BBB = 2.7, with 24 credits in required subjects.</li></ul></li></ol><hr /><h4><strong>Additional Notes</strong></h4><ul><li><strong>GCSE Equivalents:</strong> U.S. high school courses (Years 9\u201312) can count, with Algebra II or higher qualifying for math.</li><li><strong>A-Levels &amp; IB Requirements:</strong> Specific to each degree program; check directly.</li></ul><p>For detailed guidance and combination options, visit the University of Glasgow\u2019s <a href=\"https://www.gla.ac.uk/international/country/usa/#undergraduateentryrequirements\">USA Entry Requirements page</a>.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Accountancy &amp; Finance [BAcc]</li><li>Accounting &amp; Mathematics [BSc]</li><li>Accounting &amp; Statistics [BSc]</li><li>Aeronautical Engineering [BEng/MEng]</li><li>Aerospace Engineering (in partnership with SIT)</li><li>Aerospace Systems [BEng/MEng]</li><li>Anatomy [BSc/MSci]</li><li>Ancient History [MA]</li><li>Archaeology [BSc/MA/MA(SocSci)]</li><li>Astronomy [BSc/MSci]</li><li>Biochemistry [BSc/MSci]</li><li>Biomedical Engineering [BEng/MEng]</li><li>Business &amp; Management [BSc/MA/LLB/MA(SocSci)]</li><li>Business Economics [MA(SocSci)]</li><li>Celtic Civilisation [MA]</li><li>Celtic Studies [MA]</li><li>Central &amp; East European Studies [MA/MA(SocSci)]</li><li>Chemical Physics [BSc/MSci]</li><li>Chemistry [BSc/MSci]</li><li>Chemistry with Medicinal Chemistry [BSc/MSci]</li><li>Childhood Practice [BA]</li><li>Civil Engineering [BEng/MEng]</li><li>Civil Engineering (jointly offered with SIT)</li><li>Civil Engineering with Architecture [BEng/MEng]</li><li>Classics (Classical Civilisation) [MA/MA(SocSci)]</li><li>Common Law [LLB]</li><li>Common Law (graduate entry) [LLB]</li><li>Community Development [BA]</li><li>Comparative Literature [MA]</li><li>Computing Science [BSc/MA/MA(SocSci)/MSci]</li><li>Computing Science (in partnership with SIT)</li><li>Dentistry [BDS]</li><li>Design &amp; Technology Education [MDTechEd]</li><li>Digital Media &amp; Information Studies [MA]</li><li>Earth Science see: Environmental Geoscience [BSc/MSci]</li><li>Economic &amp; Social History [MA/LLB/MA(SocSci)]</li><li>Economics [BAcc/BSc/MA/MA(SocSci)]</li><li>Education with Primary Teaching Qualification [MEduc]</li><li>Electronic &amp; Software Engineering [BSc/BEng/MEng]</li><li>Electronics &amp; Electrical Engineering [BEng/MEng]</li><li>Electronics &amp; Electrical Engineering (in partnership with UESTC)</li><li>Electronics &amp; Electrical Engineering with Communication (in partnership with UESTC)</li><li>Electronics &amp; Electrical Engineering with Microelectronics (in partnership with UESTC)</li><li>Electronics with Music [BEng/MEng]</li><li>English Language &amp; Linguistics [MA]</li><li>English Literature [MA]</li><li>Environmental Geoscience [BSc/MSci]</li><li>Environmental Science &amp; Sustainability (Dumfries Campus) [BSc]</li><li>Film &amp; Television Studies [MA]</li><li>Finance [BFin]</li><li>Finance &amp; Mathematics [BSc]</li><li>Finance &amp; Statistics [BSc]</li><li>French [MA]</li><li>Gaelic [MA]</li><li>Genetics [BSc/MSci]</li><li>Geography [BSc/MA/MA(SocSci)]</li><li>Geology [BSc/MSci]</li><li>German [MA]</li><li>Greek [MA]</li><li>Health &amp; Social Sector Leadership (Dumfries Campus) [MA]</li></ul><ul id=\"majors\"><li>History [MA/MA(SocSci)]</li><li>History of Art [MA]</li><li>Human Biology [BSc/MSci]</li><li>Human Biology &amp; Nutrition [BSc/MSci]</li><li>Immunology [BSc/MSci]</li><li>International Relations [MA(SocSci)]</li><li>Italian [MA]</li><li>Latin [MA]</li><li>Law</li><li>Marine &amp; Freshwater Biology [BSc/MSci]</li><li>Materials Chemistry [BSc/MSci]</li><li>Mathematics [BSc/MA/MA(SocSci)/MSci]</li><li>Mechanical Design Engineering [BEng/MEng]</li><li>Mechanical Engineering [BEng/MEng]</li><li>Mechanical Engineering (in partnership with SIT)</li><li>Mechanical Engineering with Aeronautics [BEng/MEng]</li><li>Mechatronics [BEng/MEng]</li><li>Medicine [MBChB]</li><li>Microbiology [BSc/MSci]</li><li>Molecular &amp; Cellular Biology [BSc/MSci]</li><li>Molecular &amp; Cellular Biology (with Biotechnology) [BSc/MSci]</li><li>Molecular &amp; Cellular Biology (with Plant Science) [BSc/MSci]</li><li>Music [BMus]</li><li>Music [MA]</li><li>Neuroscience [BSc/MSci]</li><li>Nursing [BN]</li><li>Nursing (jointly offered with SIT)</li><li>Pharmacology [BSc/MSci]</li><li>Philosophy [BSc/MA/MA(SocSci)]</li><li>Physics / Theoretical Physics [BSc/MSci]</li><li>Physics with Astrophysics [BSc/MSci]</li><li>Physiology [BSc/MSci]</li><li>Physiology &amp; Sports Science [BSc/MSci]</li><li>Physiology, Sports Science &amp; Nutrition [BSc/MSci]</li><li>Politics [MA/LLB/MA(SocSci)]</li><li>Portuguese [MA]</li><li>Primary Education with Teaching Qualification (Dumfries Campus) [MA]</li><li>Primary Teaching see: Education with Primary Teaching Qualification [MEduc]</li><li>Product Design Engineering [BEng/MEng]</li><li>Psychology [BSc/MA/MA(SocSci)]</li><li>Public Policy see: Social &amp; Public Policy [MA/LLB/MA(SocSci)]</li><li>Quantitative Methods [MA(SocSci)]</li><li>Russian [MA]</li><li>Scots Law [LLB]</li><li>Scots Law (graduate entry) [LLB]</li><li>Scottish History [MA/MA(SocSci)]</li><li>Scottish Literature [MA]</li><li>Singapore programmes</li><li>Social &amp; Public Policy [MA/LLB/MA(SocSci)]</li><li>Sociology [MA/MA(SocSci)]</li><li>Software Engineering [BSc/MSci]</li><li>Software Engineering (Graduate Apprenticeship) [BSc]</li><li>Spanish [MA]</li><li>Statistics [BSc/MSci]</li><li>Theatre Studies [MA]</li><li>Theology &amp; Religious Studies [BD/MA]</li><li>UESTC programmes</li><li>Veterinary Biosciences [BSc/MSci]</li><li>Veterinary Medicine &amp; Surgery [BVMS]</li><li>Zoology [BSc/MSci]</li></ul>\n\t\t\t<a href=\"https://www.gla.ac.uk/undergraduate/degrees/\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>University of Glasgow normally acceps a <strong>Bachelor degree</strong>\u00a0with the following grade equivalencies:<br /><br /></p><ul><li>For programmes requiring a UK 2.1 Honours degree: Bachelor degree with 2.8/4</li><li>For programmes requiring a UK 2.2 Honours degree: Bachelor degree with 2.6/4</li></ul>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Academic Practice [MEd: Online distance learning available]</li><li>Adult Education for Social Change (Erasmus Mundus International Master) [IntM]</li><li>Adult Education, Community Development &amp; Youth Work [MEd/PgDip]</li><li>Advanced Functional Materials [MSc]</li><li>Advanced Practice in Veterinary Nursing [MSc/PgDip/PgCert: Online distance learning]</li><li>Advanced Statistics [MRes]</li><li>Aerospace Engineering [MSc]</li><li>Aerospace Engineering &amp; Management [MSc]</li><li>Ancient Cultures [MSc]</li><li>Animal Nutrition [MSc/PgDip/PgCert/CPD: Online distance learning]</li><li>Animal Welfare Science, Ethics &amp; Law [MSc]</li><li>Applied Linguistics [MSc]</li><li>Applied Neuropsychology [MSc(MedSci)/PgDip]</li><li>Archaeology [MSc]</li><li>Art History [MLitt]</li><li>Art History: Collecting &amp; Provenance in an International Context [MSc]</li><li>Art History: Dress &amp; Textile Histories [MLitt]</li><li>Art History: Technical Art History, Making &amp; Meaning [MLitt]</li><li>Asset Pricing &amp; Investment [MSc]</li><li>Astrophysics [MSc]</li><li>Bioinformatics [MSc/PgDip/PgCert]</li><li>Biomedical Engineering [MSc]</li><li>Biomedical Sciences [MRes]</li><li>Biomedical Sciences [MSc]</li><li>Biotechnology [MSc]</li><li>Biotechnology &amp; Management [MSc/PgDip]</li><li>Brain Sciences [MSc]</li><li>Cancer Research &amp; Precision Oncology [MSc]</li><li>Cardiovascular Sciences [MSc(MedSci)]</li><li>Central &amp; East European, Russian &amp; Eurasian Studies (Erasmus Mundus International Master) [IntM]</li><li>Chemical Biology [MSc]</li><li>Chemistry [MSc]</li><li>Chemistry with Medicinal Chemistry [MSc]</li><li>Child Health [PgCert]</li><li>Childhood Practice [MEd/PgDip]</li><li>Children&#8217;s Literature &amp; Literacies [MEd]</li><li>Children&#8217;s Literature, Media &amp; Culture (Erasmus Mundus International Master) [IntM]</li><li>Church History &amp; Theology [MTh/PgDip/PgCert]</li><li>City Planning [MSc]</li><li>City Planning &amp; Real Estate Development [MSc]</li><li>Civil Engineering [MSc]</li><li>Civil Engineering &amp; Management [MSc]</li><li>Classics &amp; Ancient History [MSc]</li><li>Clinical Critical Care [MSc/PgDip/PgCert: Online distance learning]</li><li>Clinical Genetics [MSc(MedSci)]</li><li>Clinical Neuropsychology [MSc(MedSci)/PgDip]</li><li>Clinical Neuropsychology Knowledge &amp; Practice [MSc(MedSci)]</li><li>Clinical Neuropsychology Practice [PgCert]</li><li>Clinical Nutrition [MSc(MedSci)]</li><li>Clinical Pharmacology [MSc(MedSci)]</li><li>Clinical Psychology [DClinPsy]</li><li>Comparative Literature [MLitt]</li><li>Computer Systems Engineering [MSc]</li><li>Computing Science [MSc]</li><li>Conflict Archaeology &amp; Heritage [MSc/PgDip]</li><li>Conservation Management of African Ecosystems [MSc]</li><li>Corporate &amp; Financial Law [LLM]</li><li>Corporate Governance &amp; Accountability [MSc]</li><li>Creative Industries &amp; Cultural Policy [MSc]</li><li>Creative Writing [MLitt]</li><li>Creative Writing (online) [MLitt: Online distance learning]</li><li>Criminology [MRes]</li><li>Criminology &amp; Criminal Justice [MSc]</li><li>Critical Care [MSc/PgDip/PgCert]</li><li>Critical Care &amp; Leadership [MSc/PgDip/PgCert: Online distance learning]</li><li>Critical Care, Leadership &amp; Management [MSc/PgDip/PgCert]</li><li>Curatorial Practice (Contemporary Art) (in conjunction with The Glasgow School of Art) [MLitt]</li><li>Data Analytics [MSc]</li><li>Data Analytics [MSc/PgDip/PgCert: Online distance learning]</li><li>Data Analytics for Economics &amp; Finance [MSc]</li><li>Data Analytics for Government [MSc/PgDip/PgCert: Online distance learning]</li><li>Data Science [MSc]</li><li>Developing &amp; Evaluating Interventions [MSc/PgDip/PgCert/CPD]</li><li>Development Studies [MSc]</li><li>Diabetes [MSc(MedSci)]</li><li>Digital Health Interventions [MSc/PgDip/PgCert]</li><li>Digital Society [MSc]</li><li>Diploma in Professional Legal Practice [PgDip]</li><li>Early Modern History [MSc/PgDip]</li><li>Earth Futures: Environments, Communities, Relationships [MSc]</li><li>Ecology &amp; Environmental Biology [MRes]</li><li>Economic Development [MSc]</li><li>Economics [MRes]</li><li>Economics, Banking &amp; Finance [MSc]</li><li>Education [MSc: Online distance learning]</li><li>Education (Primary) [PGDE]</li><li>Education (Secondary) [PGDE]</li><li>Education for Sustainable Futures in Adult, Community &amp; Youth Contexts [MSc]</li><li>Education in Museums &amp; Heritage [IntM]</li><li>Education Policies for Global Development (Erasmus Mundus International Master) [IntM]</li><li>Education, Public Policy &amp; Equity [MSc]</li><li>Educational Leadership [MEd]</li><li>Educational Studies [MSc]</li><li>Educational Studies [MEd]</li><li>Electronics &amp; Electrical Engineering [MSc]</li><li>Electronics &amp; Electrical Engineering &amp; Management [MSc]</li><li>Electronics &amp; Photonics Manufacturing [MSc]</li><li>End of Life Studies [MSc/PgDip/PgCert: Online distance learning]</li><li>Endodontics [MSc(DentSci)]</li><li>English Language &amp; Linguistics [MSc]</li><li>English Literature [MLitt]</li><li>English Literature: American Modern Literature [MLitt]</li><li>English Literature: Fantasy [MLitt]</li><li>English Literature: Modernities &#8211; Literature, Culture, Theory [MLitt]</li><li>English Literature: Victorian Literature [MLitt]</li><li>Enhanced Practice in Education (Dumfries Campus) [MSc]</li><li>Environment &amp; Sustainable Development [MSc]</li><li>Environment, Culture &amp; Communication (Dumfries Campus) [MLitt]</li><li>Environmental Futures: Sustainable Systems [MSc]</li><li>Environmental Risk Management (Dumfries Campus) [MSc]</li><li>Environmental Science (Glasgow-Nankai Joint Graduate School) [MSc]</li><li>Epidemiology of Infectious Diseases &amp; Antimicrobial Resistance [MSc]</li><li>Equality &amp; Human Rights [MRes]</li><li>Equality &amp; Human Rights [MSc]</li><li>Film &amp; Television Studies [MLitt]</li><li>Film Curation [MSc]</li><li>Filmmaking &amp; Media Arts [MSc]</li><li>Finance &amp; Economic Development [MSc]</li><li>Finance &amp; Management [MSc]</li><li>Financial Economics [MSc]</li><li>Financial Forecasting &amp; Investment [MSc]</li><li>Financial Risk Management [MSc]</li><li>Financial Technology [MSc]</li><li>Food Security [MSc]</li><li>Gender History [MSc/PgDip]</li><li>Genetic &amp; Genomic Counselling (with Work Placement) [MSc(MedSci)]</li><li>Geoinformation Technology &amp; Cartography [MSc/PgDip/PgCert]</li><li>Geomatics &amp; Management [MSc]</li><li>Geospatial &amp; Mapping Sciences [MSc/PgDip/PgCert]</li><li>Global Economy [MSc]</li><li>Global Health [MSc/MRes]</li><li>Global History [MSc]</li><li>Global Markets, Local Creativities (Erasmus Mundus International Master) [IntM]</li><li>Global Mental Health [MSc/PgDip/PgCert]</li><li>Global Mental Health (online) [MSc/PgDip/PgCert: Online distance learning]</li><li>Global Migrations &amp; Social Justice [MRes]</li><li>Global Migrations &amp; Social Justice [MSc]</li><li>Global Security [MRes]</li><li>Global Security [MSc]</li><li>Health Care, Advanced Practice in [MSc(MedSci)]</li><li>Health Services Management [MSc/PgDip/PgCert]</li><li>Health Technology Assessment [MSc/PgDip/PgCert: Online distance learning]</li><li>Health-Professions Education / Health-Professions Education (with Research) [MSc/MSc (Research)/PgDip/PgCert: Online distance learning]</li><li>Healthcare Chaplaincy [PgCert]Academic Practice [MEd: Online distance learning available]</li></ul><ul id=\"majors\"><li>Historically Informed Performance Practice (in conjunction with the Royal Conservatoire of Scotland) [MA]</li><li>History [MSc/PgDip]</li><li>Housing Studies [MSc/PgDip]</li><li>Human Anatomy [PgCert]</li><li>Human Geography: Spaces, Politics, Ecologies [MRes]</li><li>Human Nutrition [MSc(MedSci)]</li><li>Human Rights &amp; International Politics [MRes]</li><li>Human Rights &amp; International Politics [MSc]</li><li>Immunology &amp; Inflammatory Disease [MSc]</li><li>Inclusive Education: Research, Policy &amp; Practice [PgDip/PgCert: Online distance learning available]</li><li>Inclusive Education: Research, Policy &amp; Practice [MEd]</li><li>Industrial Heterogeneous Catalysis [MRes]</li><li>Infection Biology (with specialisms) [MSc]</li><li>Information Management &amp; Preservation [MSc/PgDip/PgCert]</li><li>Information Technology [MSc]</li><li>Intellectual Property &amp; the Digital Economy [LLM]</li><li>International Accounting &amp; Financial Management [MAcc]</li><li>International Banking &amp; Finance [MSc]</li><li>International Business [MSc]</li><li>International Commercial Law [LLM]</li><li>International Competition Law &amp; Policy [LLM]</li><li>International Corporate Finance &amp; Banking [MSc]</li><li>International Economic Law [LLM]</li><li>International Finance [MFin]</li><li>International Financial Analysis [MSc]</li><li>International Human Resource Management &amp; Development [MSc]</li><li>International Law [LLM]</li><li>International Law &amp; Security [LLM]</li><li>International Law of Global Security, Peace &amp; Development [LLM]</li><li>International Management &amp; Design Innovation [MSc]</li><li>International Real Estate &amp; Management [MSc]</li><li>International Relations [MRes]</li><li>International Relations [MSc]</li><li>International Relations (Glasgow-Nankai Joint Graduate School) [MSc]</li><li>International Strategic Marketing [MSc]</li><li>Into Headship [PgCert]</li><li>Investment Banking &amp; Finance [MSc]</li><li>Land &amp; Hydrographic Surveying [MSc/PgDip/PgCert]</li><li>Land &amp; Hydrographic Surveying with Work Placement [MSc]</li><li>Law [LLM]</li><li>Law [MRes]</li><li>Leadership in Health &amp; Social Care [PgCert: Online distance learning]</li><li>Lymphoedema Management, Advanced [PgCert]</li><li>Management [MRes]</li><li>Management [MSc]</li><li>Management &amp; Sustainable Tourism [MSc]</li><li>Management with Enterprise &amp; Business Growth [MSc]</li><li>Management with Human Resources [MSc]</li><li>Management with International Finance [MSc]</li><li>Managing Art &amp; Cultural Heritage in Global Markets [IntM]</li><li>Marketing [MSc/PgDip/PgCert: Online distance learning]</li><li>Master of Global Business [MGB]</li><li>Material Culture &amp; Artefact Studies [MSc/PgDip]</li><li>Mathematics / Applied Mathematics [MSc]</li><li>MBA (Master of Business Administration) [MBA]</li><li>Mechanical Engineering [MSc]</li><li>Mechanical Engineering &amp; Management [MSc]</li><li>Mechatronics [MSc]</li><li>Media Management [MSc]</li><li>Media, Communications &amp; International Journalism [MSc]</li><li>Media, Culture &amp; Society [MSc]</li><li>Medical Devices Engineering [MSc]</li><li>Medical Genetics &amp; Genomics [MSc(MedSci)]</li><li>Medical Physics [MSc]</li><li>Medical Visualisation &amp; Human Anatomy [MSc]</li><li>Medieval History [MSc/PgDip]</li><li>Middle Leadership &amp; Management in Schools [PgCert]</li><li>Ministry, Theology &amp; Practice [MTh/PgDip/PgCert]</li><li>Modern History [MSc/PgDip]</li><li>Museum Education [MSc]</li><li>Museum Education (online) [MSc: Online distance learning]</li><li>Museum Studies [MSc/PgDip/PgCert]</li><li>Music Industries [MSc]</li><li>Musicology [MMus]</li><li>Nanoscience &amp; Nanotechnology [MSc]</li><li>Nuclear &amp; Environmental Physics [MSc]</li><li>Nursing Science, Advanced [MSc]</li><li>One Health [MSc/PgDip/PgCert: Online distance learning]</li><li>Oral &amp; Maxillofacial Surgery [MSc(DentSci)]</li><li>Oral Sciences [MSc]</li><li>Palliative Care [MSc/PgDip/PgCert: Online distance learning]</li><li>Philosophy [MSc]</li><li>Philosophy (Conversion) [MSc]</li><li>Philosophy of Mind &amp; Psychology [MSc]</li><li>Playwriting &amp; Dramaturgy [MLitt]</li><li>Political Communication [MRes]</li><li>Political Communication [MSc/PgDip]</li><li>Positive Behaviour Support [PgCert: Blended learning]</li><li>Precision Medicine &amp; Pharmacological Innovation [MSc]</li><li>Precision Medicine (with specialisms) [MSc]</li><li>Primary Health Care [MSc/PgDip/PgCert: Online distance learning]</li><li>Product Design Engineering [MSc]</li><li>Professional Practice with PGDE [MEd]</li><li>Psychological Science (conversion) [MSc]</li><li>Psychological Science, Research Methods of [MSc]</li><li>Psychological Studies (conversion) [MSc]</li><li>Psychology (conversion) [MSc: Online distance learning]</li><li>Public &amp; Urban Policy [MSc/PgDip]</li><li>Public Health [MPH/PgDip/PgCert]</li><li>Public Health (online) [MPH/PgDip/PgCert: Online distance learning]</li><li>Public Policy &amp; Management [MSc]</li><li>Public Policy Research [MRes]</li><li>Quantitative Finance [MSc]</li><li>Quantitative Methods in Biodiversity, Conservation &amp; Epidemiology [MSc]</li><li>Quantum Technology [MSc]</li><li>Real Estate [MSc]</li><li>Real Estate [PgCert]</li><li>Religious Education by Distance Learning (CREDL) [Cert: Online distance learning]</li><li>Robotics &amp; AI [MSc]</li><li>Russian, East European &amp; Eurasian Studies [MSc]</li><li>Russian, East European &amp; Eurasian Studies [MRes]</li><li>Scottish History [MSc/PgDip]</li><li>Security, Intelligence &amp; Strategic Studies (Erasmus Mundus International Master) [IntM]</li><li>Sensor &amp; Imaging Systems [MSc]</li><li>Slavery, Forced Migration &amp; Reparative Justice [IntM]</li><li>Sociology [MSc]</li><li>Sociology &amp; Research Methods [MRes]</li><li>Software Development [MSc]</li><li>Sound Design &amp; Audiovisual Practice [MSc]</li><li>South European Studies (Erasmus Mundus International Master) [IntM]</li><li>Spatial Planning [PgCert]</li><li>Speech, Language &amp; Sociolinguistics [MSc]</li><li>Sport &amp; Exercise Science &amp; Medicine [MSc/PgDip/PgCert: Online distance learning]</li><li>Sport &amp; Exercise Science &amp; Medicine [MSc]</li><li>Sports Nutrition [PgCert]</li><li>Statistics [MSc]</li><li>Stem Cell Engineering for Regenerative Medicine [MSc]</li><li>Structural Engineering [MSc]</li><li>Sustainable Energy [MSc]</li><li>Sustainable Water Environments [MSc]</li><li>Teacher Leadership &amp; Learning [PgCert]</li><li>TESOL: Teaching of English to Speakers of Other Languages [MEd]</li><li>TESOL: Teaching of English to Speakers of Other Languages [MSc]</li><li>Textile Conservation [MPhil]</li><li>Theatre &amp; Performance Practices [MLitt]</li><li>Theatre Studies [MLitt]</li><li>Theoretical Physics [MSc]</li><li>Tourism Development &amp; Culture (Erasmus Mundus Joint Master) (Dumfries Campus) [MSc]</li><li>Tourism, Heritage &amp; Development (Dumfries Campus) [MSc]</li><li>Tourism, Heritage &amp; Sustainability (Dumfries Campus) [MSc]</li><li>Translation Studies [MSc/PgDip/PgCert]</li><li>Transnational Crime, Justice &amp; Security [MSc]</li><li>Urban &amp; Regional Planning (Glasgow-Nankai Joint Graduate School) [MSc]</li><li>Urban Analytics [MSc]</li><li>Urban Research [MRes]</li><li>Urban Studies [PgCert]</li><li>Urban Transport [MSc]</li><li>War Studies [MSc]</li></ul>\n\t\t\t<a href=\"https://www.gla.ac.uk/postgraduate/taught/\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"https://www.gla.ac.uk/postgraduate/taught/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://twitter.com/UofGlasgow\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.instagram.com/uofglasgow\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.youtube.com/user/universityofglasgow\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gla.ac.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gla.ac.uk/international/country/usa/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gla.ac.uk/undergraduate/fees/intlfees/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gla.ac.uk/scholarships/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gla.ac.uk/myglasgow/registry/finance/federalloans/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gla.ac.uk/explore/visit/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gla.ac.uk/research/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gla.ac.uk/myglasgow/accommodation/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gla.ac.uk/myglasgow/careers/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.glasgowunisrc.org/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"https://www.gla.ac.uk/undergraduate/howtoapply/\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"University of Glasgow","post_link":"https://theukstudyexpert.com/universities/glasgow/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Glasgow\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Glasgow-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, Health Medicine, Humanities, Life Physical Sciences, Scotland, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"5","taxonomy=category":"Universities","taxonomy=post_tag":"3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, Health Medicine, Humanities, Life Physical Sciences, Scotland, Social Science, Technology Computer Science","city_country":"Glasgow, Scotland"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10194,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Goldsmiths, University of London","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Goldsmiths University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Goldsmiths-University-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/goldsmithslondon/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Goldsmiths, University of London</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Founded in 1891, Goldsmiths, University of London offers a range of undergraduate and postgraduate study options in several academic departments. \r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Founded in 1891, Goldsmiths, University of London offers a range of undergraduate and postgraduate study options in several academic departments. ","address":"288 New Cross Rd, London SE14, UK","location":{"lat":"51.47529900000001","state":"England","country":"United Kingdom","lng":"-0.03820370000000001","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/goldsmithslondon/","zoom":5,"extra_fields":{"post_excerpt":"Founded in 1891, Goldsmiths, University of London offers a range of undergraduate and postgraduate study options in several academic departments. ","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Goldsmiths.png\" alt=\"Goldsmiths, University of London\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Goldsmiths-1.png\" alt=\"Goldsmiths, University of London\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Goldsmiths-2.png\" alt=\"Goldsmiths, University of London\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact Goldsmiths, University of London\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> New Cross, London, SE14 6NW</p><p><strong>Website:</strong> <a href=\"https://www.gold.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://gold.ac.uk/</a></p><h3>Overview</h3><p>Founded in 1891, Goldsmiths, University of London offers a range of undergraduate and postgraduate study options in the fine and performing arts, humanities, social sciences, law, computer science, psychology, and entrepreneurial business and management.</p><p>\u00a0</p><p>Goldsmiths has a close-knit community of 10,000 students based on an urban campus in South East London. Our vibrant neighborhood, New Cross, has a thriving music and arts scene, fantastic restaurants, buzzing cafes, and a genuinely diverse and eclectic population. Plus, it\u2019s a less than 10-minute journey away from the center of London.</p><p>\u00a0</p><p>Goldsmiths is ranked in the top 100 universities in the world for the arts and humanities (QS World University Rankings by Subject 2021) and we are ranked 9th in the United Kingdom for Research Intensity (Complete University Guide 2022).</p><p>\u00a0</p><p><strong>Population: </strong>10,000</p><p><strong>Campus Type: </strong>Urban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li><p>Goldsmiths was founded in 1891 and has been a member of the University of London since 1904.</p></li><li><p>35% international from over 135 countries, 48% students of color, 18% LGBTQ+, 43% first generation, and around 380 Americans on campus</p></li><li><p>Goldsmiths is home to seven top 100 subjects, putting us in the top 30 in the UK (QS World University Rankings 2023)</p></li><li><p>Student-faculty ratio is 14:1, ranked 14th in the UK (Complete University Guide 2023)</p></li><li><p>Goldsmiths hosts 50 research centres and units on campus, and we are ranked joint 1st in the UK in nine subject areas for research intensity (Complete University Guide 2023)</p></li><li><p>Nearly 90% of our alumni are in highly skilled work or further study within 15 months of graduation (Graduate Outcomes Survey 2022)</p></li></ul>\t\t\n\t\t<h3>Videos</h3>https://www.youtube.com/watch?v=vImejEa_HMkhttps://player.vimeo.com/video/395432110https://player.vimeo.com/video/234699706https://player.vimeo.com/video/390711836\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p>Goldsmiths operates on both a <strong>test optional</strong> and <strong>test flexible</strong> admissions policy. Students who currently have, or will have, test results are welcome to submit them for consideration as part of their application. However, students who are unable to submit test results will not be disadvantaged. When making admissions decisions, Goldsmiths uses a holistic review process, taking a variety of factors into account including your personal statement, letter of reference, extracurricular activities, test scores, and academic grades. On some <a href=\"https://www.gold.ac.uk/course-finder/\">programmes</a>, portfolios, auditions, or subject-specific grades are also required.<br /><br /></p><p>For High School applicants, Goldsmiths requires the following academic qualifications in one of two options:<br /><br /></p><p>A high school diploma with a GPA 3.0 or higher (unweighted) plus one of the following:</p><ul data-rte-list=\"default\"><li><p>ACT with a composite score of 26,</p></li><li><p>Two advanced placement (AP) tests with a score of 3 or higher,</p></li><li><p>SAT 1240 overall (with a minimum of 580 in Math and 620 in Evidence-based Reading and Writing)</p></li></ul><p>OR<br /><br /></p><p>A high school diploma with a GPA 3.3 or higher (unweighted) with grades of A and B in honours- or advanced-level courses, advanced placement (AP) classes, or dual enrollment within the context of your high school\u2019s curriculum.<br /><br /></p><p>Goldsmiths utilizes AP, IB, and SAT/ACT test results for admissions purposes only. No advanced entry or course credit will be awarded. We will superscore both the ACT and the SAT.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Anthropology and Media BA</li><li>Anthropology and Sociology BA</li><li>Anthropology and Visual Practice BA</li><li>Anthropology BA</li><li>Anthropology with Foundation Year (Integrated Degree) BA</li><li>Arts Management BA</li><li>Business Computing and Entrepreneurship BSc</li><li>Business Computing and Entrepreneurship with Foundation Year BSc</li><li>Computer Science BSc</li><li>Computer Science with Foundation Year (Integrated Degree) BSc</li><li>Computing and Information Systems BSc</li><li>Computing BSc</li><li>Creative Computing BSc</li><li>Creative Computing with Foundation Year (Integrated Degree) BSc</li><li>Criminology BA</li><li>Curating BA</li><li>Data Science BSc</li><li>Design BA</li><li>Digital Anthropology BA</li><li>Digital Arts Computing BSc</li><li>Drama and Theatre Arts BA</li><li>Drama: Musical Theatre BA</li><li>Drama: Performance, Politics and Society BA</li><li>Economics BA</li><li>Economics with Econometrics BSc</li><li>Economics with Marketing BA</li><li>Economics, Politics and Public Policy BA</li><li>Education, Culture and Society BA</li><li>Electronic Music, Computing and Technology BMus/BSc</li><li>English BA</li><li>English with Creative Writing BA</li><li>English with Foundation Year (Integrated Degree) BA</li><li>Fine Art (Extension Degree) BA</li><li>Fine Art and History of Art BA</li><li>Fine Art BA</li><li>Games Programming BSc</li><li>History and Journalism BA</li><li>History BA</li><li>History of Art BA</li><li>History with Anthropology BA</li><li>History with Foundation Year (Integrated Degree) BA</li><li>History with Global History BA</li><li>History with Military History BA</li><li>History with Politics BA</li><li>History with Public History BA</li></ul><ul id=\"majors\"><li>International Foundation Certificate (Arts and Humanities, Computing, Media, Culture and Society, Music Computing, Social Sciences)</li><li>International Foundation Certificate (Design, Management and Psychology, Music)</li><li>International Relations and Chinese BA</li><li>International Relations BA</li><li>Journalism BA</li><li>Law LLB</li><li>Law with Criminal Justice and Human Rights LLB</li><li>Law with Politics and Human Rights LLB</li><li>Management with Economics BSc</li><li>Management with Entrepreneurship BSc</li><li>Management with Marketing BSc</li><li>Marketing BSc</li><li>Media and Communications BA</li><li>Media and Communications with Foundation Year (Integrated Degree) BA</li><li>Media and English BA</li><li>Music BMus</li><li>Politics and International Relations BA</li><li>Politics BA</li><li>Politics, Philosophy and Economics BA</li><li>Popular Music BMus</li><li>Promotional Media BA</li><li>Psychology (including Profesional Placement Year) BSc</li><li>Psychology BSc</li><li>Psychology with Clinical Psychology (including Profesional Placement Year) BSc</li><li>Psychology with Clinical Psychology BSc</li><li>Psychology with Cognitive Neuroscience (including Profesional Placement Year) BSc</li><li>Psychology with Cognitive Neuroscience BSc</li><li>Psychology with Forensic Psychology (including Profesional Placement Year) BSc</li><li>Psychology with Forensic Psychology BSc</li><li>Psychology with Foundation Year (Integrated Degree) BSc</li><li>Psychology with Management (including Profesional Placement Year) BSc</li><li>Psychology with Management BSc</li><li>Psychosocial Studies BA</li><li>Social and Community Work BA</li><li>Social and Cultural Studies BA</li><li>Social Science, Community Development and Youth Work BA</li><li>Social Work BA</li><li>Sociology and Chinese BA</li><li>Sociology and Politics BA</li><li>Sociology BA</li><li>Sociology with Criminology BA</li></ul>\n\t\t\t<a href=\"http://www.gold.ac.uk/ug\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>For Goldsmiths entry to postgraduate programmes you will normally need a Bachelor\u2019s degree in a subject relevant to your proposed area of postgraduate study.</p><p>\u00a0</p><p>The majority of programs require either a 3.0 or 3.2 minimum GPA from your undergraduate degree.</p><p>\u00a0</p><p>Specific entrance requirements (including portfolios) and application deadlines may also apply in some Goldsmiths subjects. Please refer to individual course pages to find out what these are.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Advanced Practices MPhil/PhD</li><li>Advanced Practices MRes</li><li>Anthropology and Museum Practice MA</li><li>Anthropology MPhil/PhD</li><li>Anthropology MRes</li><li>Anthropology, Ecology and Global Justice MA</li><li>Applied Anthropology and Community Arts MA</li><li>Applied Anthropology and Community Development MA</li><li>Applied Anthropology, Community and Youth Work MA</li><li>Applied Theatre: Drama in Educational, Community and Social Contexts MA</li><li>Art &#8211; Pathway 1: Thesis by Practice MPhil/PhD</li><li>Art &#8211; Pathway 2: Thesis by Practice and Written Dissertation MPhil/PhD</li><li>Art &#8211; Pathway 3: Thesis by Written Dissertation MPhil/PhD</li><li>Art and Ecology MA</li><li>Art and Politics MA</li><li>Art Practice and Learning MPhil/PhD</li><li>Art Psychotherapy MA</li><li>Art Psychotherapy MPhil/PhD</li><li>Art Writing MFA</li><li>Artists&#8217; Film &amp; Moving Image MA</li><li>Arts Administration and Cultural Policy &#8211; Pathway: Music MA</li><li>Arts Administration and Cultural Policy MA</li><li>Arts and Computational Technology MPhil/PhD</li><li>Arts and Learning MA</li><li>Black British History MA</li><li>Black British Literature MA</li><li>Brands, Communication and Culture MA</li><li>Children&#8217;s Literature &#8211; Pathway 1: Issues and Debates MA</li><li>Children&#8217;s Literature &#8211; Pathway 2: Creative Writing MA</li><li>Children&#8217;s Literature: Children&#8217;s Illustration MA</li><li>Cognitive and Clinical Neuroscience MSc</li><li>Cognitive Behavioural Therapy MSc</li><li>Community and Youth Work MPhil/PhD</li><li>Composition MMus</li><li>Computational Arts MA</li><li>Computational Arts MFA</li><li>Computational Cognitive Neuroscience MSc</li><li>Computer Games Programming MSc</li><li>Computer Games: Art and Design MA</li><li>Computer Science MPhil/PhD</li><li>Consumer Behaviour MSc</li><li>Contemporary Art Theory MA</li><li>Counselling and Psychotherapy MPhil/PhD</li><li>Counselling MA</li><li>Creative and Cultural Entrepreneurship &#8211; Pathway 1: Computing MA</li><li>Creative and Cultural Entrepreneurship &#8211; Pathway 2: Design MA</li><li>Creative and Cultural Entrepreneurship &#8211; Pathway 3: Fashion MA</li><li>Creative and Cultural Entrepreneurship &#8211; Pathway 4: Media and Communications MA</li><li>Creative and Cultural Entrepreneurship &#8211; Pathway 5: Music MA</li><li>Creative and Cultural Entrepreneurship &#8211; Pathway 6: Theatre and Performance MA</li><li>Creative and Cultural Entrepreneurship &#8211; Pathway 8: Entrepreneurial Leadership MA</li><li>Creative and Cultural Entrepreneurship MPhil/PhD</li><li>Creative and Life Writing MA</li><li>Creative Practice MMus</li><li>Creative Writing and Education MA</li><li>Creative Writing MPhil/PhD</li><li>Cultural Policy, Relations and Diplomacy MA</li><li>Cultural Studies MA</li><li>Cultural Studies MPhil/PhD</li><li>Culture Industry MA</li><li>Curating MFA</li><li>Curating MPhil/PhD</li><li>Dance Movement Psychotherapy MA</li><li>Dance Movement Psychotherapy MPhil/PhD</li><li>Data Science MSc</li><li>Design MPhil/PhD</li><li>Design MRes</li><li>Design: Expanded Practice &#8211; Pathway 1: Communication and Experience MA</li><li>Design: Expanded Practice &#8211; Pathway 2: Fashions and Embodiment MA</li><li>Design: Expanded Practice &#8211; Pathway 3: Innovation and Service MA</li><li>Design: Expanded Practice &#8211; Pathway 4: Interactions and Engagement MA</li><li>Design: Expanded Practice &#8211; Pathway 5: Spaces &amp; Participation MA</li><li>Digital Journalism MA</li><li>Digital Media &#8211; Pathway 1: Theory MA</li><li>Digital Media &#8211; Pathway 2: Theory and Practice (Image Making) MA</li><li>Digital Media &#8211; Pathway 3: Theory and Practice (Critical Computing) MA</li><li>Drama &#8211; Pathway 1: Theory MPhil/PhD</li><li>Drama &#8211; Pathway 2: Practice MPhil/PhD</li><li>Dramaturgy and Writing for Performance MA</li><li>Ecology, Culture and Society MA</li><li>Education MPhil/PhD</li><li>Education: Culture, Language and Identity &#8211; Pathway A MA</li><li>Education: School Based Explorations MA</li><li>English MPhil/PhD</li><li>English MRes</li><li>Events and Experience Management MA</li><li>Film and Screen Studies MA</li><li>Filmmaking &#8211; Pathway 1: Directing Fiction MA</li><li>Filmmaking &#8211; Pathway 2: Producing MA</li><li>Filmmaking &#8211; Pathway 3: Screen Documentary MA</li><li>Filmmaking &#8211; Pathway 4: Cinematography MA</li></ul><ul id=\"majors\"><li>Filmmaking &#8211; Pathway 5: Sound Recording, Post Production and Design MA</li><li>Filmmaking &#8211; Pathway 6: Editing MA</li><li>Filmmaking, Photography and Electronic Arts MRes</li><li>Fine Art MFA</li><li>Forensic Psychology MSc</li><li>Foundations in Clinical Psychology and Health Services MSc</li><li>Gender, Media and Culture MA</li><li>Global Media and Politics MA</li><li>Global Political Economy MA</li><li>Graduate Diploma in Contemporary Art History</li><li>History MA</li><li>History MPhil/PhD</li><li>History MRes</li><li>Human Rights, Culture &amp; Social Justice MA</li><li>Independent Games and Playable Experience Design MA</li><li>International Relations MA</li><li>Journalism MA</li><li>Law MPhil/PhD</li><li>Literary and Critical Theory MPhil/PhD</li><li>Literary Studies &#8211; Pathway 1: Comparative</li><li>Literature and Criticism MA</li><li>Literary Studies &#8211; Pathway 2: Critical Theory MA</li><li>Literary Studies &#8211; Pathway 3: Modern Literature MA</li><li>Literary Studies &#8211; Pathway 4: Literature of the Caribbean and its Diasporas MA</li><li>Literary Studies &#8211; Pathway 5: American Literature and Culture MA</li><li>Literary Studies &#8211; Pathway 6: Romantic and Victorian Literature and Culture MALuxury Brand Management MA</li><li>Management MPhil/PhD</li><li>Management of Innovation MSc</li><li>Management of Learning and Teaching In Higher Education MA</li><li>Marketing and Technology MSc</li><li>Media and Communications MA</li><li>Media and Communications MPhil/PhD</li><li>Media and Communications MRes</li><li>Migration and Mobility MA</li><li>Multilingualism, Linguistics and Education MA</li><li>Music &#8211; Audiovisual Cultures MA</li><li>Music &#8211; Contemporary Music Studies MA</li><li>Music &#8211; Ethnomusicology MA</li><li>Music &#8211; Musicology MA</li><li>Music &#8211; Popular Music Research MA</li><li>Music (Performance) MPhil/PhD</li><li>Music MA</li><li>Music MPhil/PhD</li><li>Music, Mind and Brain MSc</li><li>Musical Theatre MA</li><li>Occupational Psychology MSc</li><li>Performance and Culture MA</li><li>Performance and Related Studies MMus</li><li>Performance Making MA</li><li>Photography and Urban Cultures MA</li><li>Photography: The Image and Electronic Arts MA</li><li>Photography: The Image and Electronic Arts</li><li>Political Communications MA</li><li>Politics MPhil/PhD</li><li>Politics, Development and The Global South MA</li><li>Popular Music MMus</li><li>Postcolonial Culture and Global Policy MA</li><li>Promotional Media: Public Relations, Advertising and Marketing MA</li><li>Psychology (Management) MPhil/PhD</li><li>Psychology (Science) MPhil/PhD</li><li>Psychology of The Arts, Neuroaesthetics &amp; Creativity MSc</li><li>Queer History MA</li><li>Race, Media and Social Justice MA</li><li>Radio MA</li><li>Religious Studies MPhil/PhD</li><li>Research Architecture MA</li><li>Research Architecture MPhil/PhD</li><li>Research Methods in Psychology MRes</li><li>Script Writing MA</li><li>Social Anthropology MA</li><li>Social Entrepreneurship MA</li><li>Social Research MSc</li><li>Social Work MA</li><li>Social Work MPhil/PhD</li><li>Sociocultural Linguistics MA</li><li>Sociology (Cultural Analysis) MA</li><li>Sociology (Urban Studies) MA</li><li>Sociology (Visual Sociology) MA</li><li>Sociology MA</li><li>Sociology MPhil/PhD</li><li>Sociology MRes</li><li>Sonic Arts MMus</li><li>Television Journalism MA</li><li>Tourism and Cultural Policy MA</li><li>Translation by Practice MPhil/PhD</li><li>Translation MA</li><li>Translation MPhil/PhD</li><li>Understanding Domestic Violence and Sexual Abuse (Distance Learning) MA</li><li>Understanding Domestic Violence and Sexual Abuse MA</li><li>User Experience Engineering MSc</li><li>Virtual and Augmented Reality &#8211; Pathway 1: 3D Graphics and User Experience MA</li><li>Virtual and Augmented Reality &#8211; Pathway 2: Programming and Computer Science MSc</li><li>Visual Anthropology MA</li><li>Visual Anthropology MPhil/PhD</li><li>Visual Anthropology MRes</li><li>Visual Cultures MPhil/PhD</li><li>Visual Cultures MRes</li><li>Visual Sociology MPhil/PhD</li><li>World Theatres MA</li></ul>\n\t\t\t<a href=\"http://www.gold.ac.uk/pg\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"http://www.facebook.com/GoldsmithsUoL\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.twitter.com/GoldsmithsUoL\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.instagram.com/GoldsmithsUoL\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://www.youtube.com/user/goldsmithslondon\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gold.ac.uk/\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gold.ac.uk/international/regions/usa/\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gold.ac.uk/fees-funding/\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gold.ac.uk/fees-funding/scholarships/?filter%5Bfeestatus%5D=International\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gold.ac.uk/students/fee-support/usa-student-funding/usloans/\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gold.ac.uk/international/visit-us/\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gold.ac.uk/research/\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gold.ac.uk/accommodation/\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.gold.ac.uk/careers/\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.goldsmithssu.org/\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"http://www.gold.ac.uk/apply\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>","post_title":"Goldsmiths, University of London","post_link":"https://theukstudyexpert.com/universities/goldsmithslondon/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Goldsmiths University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Goldsmiths-University-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, England, Humanities, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, England, Humanities, Social Science, Technology Computer Science","city_country":"London, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10182,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"University of Bangor","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Bangor\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Bangor-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/bangor/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Bangor</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Founded in 1884, dedicated to academic excellence for more than 135 years, Bangor University is one of the oldest and most prestigious degree awarding institutions in the UK.?\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Founded in 1884, dedicated to academic excellence for more than 135 years, Bangor University is one of the oldest and most prestigious degree awarding institutions in the UK.?","address":"Bangor LL57 2DG, UK","location":{"lat":"53.2295205","state":"Wales","country":"United Kingdom","lng":"-4.1299873","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/bangor/","zoom":5,"extra_fields":{"post_excerpt":"Founded in 1884, dedicated to academic excellence for more than 135 years, Bangor University is one of the oldest and most prestigious degree awarding institutions in the UK.?","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Bangor.png\" alt=\"University of Bangor\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Bangor-1.png\" alt=\"University of Bangor\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Bangor-2.png\" alt=\"University of Bangor\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Bangor-3.png\" alt=\"University of Bangor\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Bangor-4.png\" alt=\"University of Bangor\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/11/Bangor-5.png\" alt=\"University of Bangor\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact Bangor University\r\n</a>\r\n\r\n<strong>Location:</strong> Bangor, Gwynedd, Wales, LL57 2DG, United Kingdom\r\n\r\n<strong>Website:</strong> <a href=\"https://bangor.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://bangor.ac.uk/</a>\r\n<h3>Overview</h3>\r\nNestled amidst the breathtaking landscapes of North Wales, Bangor University stands as a beacon of academic excellence and natural beauty. Established in 1884, this venerable institution has evolved into a globally recognized center of learning, research, and innovation. Located in the charming coastal city of Bangor, the university's unique setting enriches the academic experience and offers a distinctive blend of tradition and modernity.\r\n\r\nBangor University is renowned for its academic rigor and commitment to nurturing intellectual growth. It offers a wide array of undergraduate, postgraduate, and research programs across various disciplines, including arts and humanities, natural sciences, social sciences, business, and health sciences. The university's emphasis on research-led teaching ensures that students receive cutting-edge knowledge and engage with world-class scholars in their fields.\r\n\r\nThe university's research activities have garnered international recognition, with several departments achieving top rankings in the UK's Research Excellence Framework (REF). From marine biology and environmental science to psychology and linguistics, Bangor's research initiatives span a diverse range of subjects. The proximity to the stunning landscapes of Snowdonia National Park and the Irish Sea provides unique opportunities for ecological, environmental, and marine research.\r\n\r\nBangor University's campus is renowned for its stunning natural surroundings. Situated between the majestic Snowdonia mountains and the rugged Welsh coastline, students have the unique opportunity to explore the great outdoors, fostering a sense of well-being and adventure. The city of Bangor itself is a lively and friendly community, offering a blend of traditional Welsh culture and modern amenities.\r\n\r\nWith a diverse student body hailing from across the globe, Bangor University is a truly international institution. The university's commitment to inclusivity and diversity ensures a welcoming and supportive environment for students of all backgrounds. The cultural exchange that takes place on campus enriches the educational experience and prepares graduates for a globalized world.\r\n\r\nBangor University in Wales is a venerable institution that seamlessly blends a rich history with a commitment to academic excellence and innovation. Its dedication to research, diverse student body, and spectacular natural setting make it a unique destination for those seeking a world-class education in a truly inspiring environment. Whether you're drawn to its research opportunities, scenic landscapes, or cultural diversity, Bangor University continues to stand as a beacon of higher learning in the heart of Wales.\r\n\r\n<strong>Population: </strong>10,505\r\n\r\n<strong>Campus Type: </strong>Rural\r\n<h3>Quick Facts</h3>\r\n<ul data-rte-list=\"default\">\r\n \t<li>At Bangor university we have our own Botanical gardens, museum and research ship!</li>\r\n \t<li>Bangor's population is approximately 30,000 \u2013 but one-third of that population consists of students.</li>\r\n \t<li>Top 10 in the UK for University of the Year (WhatUni, 2023)</li>\r\n \t<li>No.3 in the UK for Student Accommodation (WhatUni, 2023)</li>\r\n \t<li>Over 150 societies and clubs that are free to join</li>\r\n \t<li>University Sports centre which hosted the Chinese Olympic weightlifting team</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://www.youtube.com/watch?v=miFi6R96c_khttps://www.youtube.com/watch?v=hQaSRQTXJoAhttps://www.youtube.com/watch?v=0lBY8xVHPNc\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nThe minimum we require for consideration is:\r\n\r\nSuccessful completion of High School Graduation Diploma with an unweighted GPA 3.0 or higher, plus <strong>one</strong> of the following:\r\n<ul data-rte-list=\"default\">\r\n \t<li>2 AP exams (with a score of 3+) or Honours/DE/College-prep courses related to the subject you have chosen to with a minimum grade C in each.</li>\r\n \t<li>ACT 26+</li>\r\n \t<li>SAT 1100+</li>\r\n \t<li>2 completed semesters of community college classes.</li>\r\n</ul>\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n<ul>\r\n \t<li>Accounting, Banking and Finance</li>\r\n \t<li>Biology</li>\r\n \t<li>Business Data Analytics</li>\r\n \t<li>Business, Management and Marketing</li>\r\n \t<li>Childhood and Youth Studies</li>\r\n \t<li>Chinese</li>\r\n \t<li>Computer Science</li>\r\n \t<li>Conservation</li>\r\n \t<li>Creative Writing and Professional Writing</li>\r\n \t<li>Criminology and Criminal Justice</li>\r\n \t<li>Data Science</li>\r\n \t<li>Dental Hygiene</li>\r\n \t<li>Drama, Theatre and Performance</li>\r\n \t<li>Economics</li>\r\n \t<li>Engineering</li>\r\n \t<li>English</li>\r\n \t<li>English Language</li>\r\n \t<li>English Literature</li>\r\n \t<li>Environmental Science</li>\r\n \t<li>Film</li>\r\n \t<li>Forestry</li>\r\n \t<li>French</li>\r\n \t<li>Geography</li>\r\n \t<li>Geology</li>\r\n \t<li>German</li>\r\n \t<li>Health and Social Care</li>\r\n \t<li>History, Archaeology and Heritage</li>\r\n \t<li>Italian</li>\r\n \t<li>Journalism</li>\r\n \t<li>Law</li>\r\n \t<li>Linguistics</li>\r\n \t<li>Marine Biology</li>\r\n \t<li>Media</li>\r\n \t<li>Medical Sciences</li>\r\n \t<li>Medicine</li>\r\n \t<li>Midwifery</li>\r\n \t<li>Modern Languages</li>\r\n \t<li>Music</li>\r\n \t<li>Nuclear</li>\r\n \t<li>Nursing</li>\r\n \t<li>Ocean Sciences</li>\r\n \t<li>Pharmacology</li>\r\n \t<li>Philosophy and Religion</li>\r\n \t<li>Physics</li>\r\n \t<li>Policing</li>\r\n \t<li>Politics</li>\r\n \t<li>Product Design</li>\r\n \t<li>Psychology</li>\r\n \t<li>Sociology and Social Policy</li>\r\n \t<li>Spanish</li>\r\n \t<li>Sport and Exercise Sciences</li>\r\n \t<li>Radiography</li>\r\n \t<li>Teaching</li>\r\n \t<li>Tourism</li>\r\n \t<li>Welsh</li>\r\n \t<li>Zoology</li>\r\n</ul>\r\n<a href=\"http://www.bangor.ac.uk/study/undergraduate\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nMinimum GPA of 3.0 from a reputable university. No GRE requirement, however we do request a personal statement, transcripts and a research proposal where appropriate. Each application is assessed individually.\r\n\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n<ul>\r\n \t<li>Accounting, Banking and Finance</li>\r\n \t<li>Applied Innovation Design</li>\r\n \t<li>Applied Psychology</li>\r\n \t<li>Applied Psychology</li>\r\n \t<li>Biology</li>\r\n \t<li>Biotechnology</li>\r\n \t<li>Business, Management and Marketing</li>\r\n \t<li>Celtic and Medieval Studies</li>\r\n \t<li>Computer Science</li>\r\n \t<li>Conservation</li>\r\n \t<li>Creative Writing</li>\r\n \t<li>Criminology and Criminal Justice</li>\r\n \t<li>Data Science</li>\r\n \t<li>Education</li>\r\n \t<li>Electronic Engineering</li>\r\n \t<li>English Literature</li>\r\n \t<li>English Language</li>\r\n \t<li>Environmental Science</li>\r\n \t<li>Executive Education</li>\r\n \t<li>Film, Media and Journalism</li>\r\n \t<li>Forestry</li>\r\n \t<li>Health Sciences</li>\r\n \t<li>History and Heritage</li>\r\n \t<li>Law</li>\r\n \t<li>Linguistics, English Language &amp; Bilingualism</li>\r\n \t<li>Marine Biology</li>\r\n \t<li>Medical Education</li>\r\n \t<li>Medical Sciences</li>\r\n \t<li>Midwifery</li>\r\n \t<li>Music</li>\r\n \t<li>Nanotechnology</li>\r\n \t<li>Neuroscience</li>\r\n \t<li>Nursing</li>\r\n \t<li>Ocean Sciences</li>\r\n \t<li>Physician Associate</li>\r\n \t<li>Physics</li>\r\n \t<li>Physiotherapy</li>\r\n \t<li>Psychology</li>\r\n \t<li>Renewables</li>\r\n \t<li>Social Work</li>\r\n \t<li>Sociology and Social Policy</li>\r\n \t<li>Sport and Exercise Sciences</li>\r\n \t<li>Teaching</li>\r\n \t<li>Translation Studies</li>\r\n \t<li>Welsh</li>\r\n</ul>\r\n<a href=\"http://www.bangor.ac.uk/study/postgraduate\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/universityoflincoln/\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://twitter.com/unilincoln\" target=\"_blank\" rel=\"noopener\">\r\nTwitter\r\n</a>\r\n<a href=\"https://www.instagram.com/unilincoln/\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/c/universityoflincoln/videos\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"http://www.bangor.ac.uk\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"http://www.bangor.ac.uk/international/countries/usa\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"http://www.bangor.ac.uk/international/fees\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.bangor.ac.uk/international/scholarship\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.bangor.ac.uk/international/aid-us-students\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"http://www.bangor.ac.uk/events\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"http://www.bangor.ac.uk/research\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.bangor.ac.uk/international/accommodation\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.bangor.ac.uk/student-life/employability\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.bangor.ac.uk/student-life/clubs_societies\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"http://www.bangor.ac.uk/international/applying\" target=\"_blank\" rel=\"noopener\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"University of Bangor","post_link":"https://theukstudyexpert.com/universities/bangor/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Bangor\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/University-of-Bangor-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"","%_custom_priority_meta_key%":"4","taxonomy=category":"Universities","taxonomy=post_tag":"","city_country":"Bangor, Wales"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10180,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]}],"styles":"[\r\n    {\r\n        \"featureType\": \"administrative\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"on\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative\",\r\n        \"elementType\": \"geometry.fill\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"on\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative\",\r\n        \"elementType\": \"geometry.stroke\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"on\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"administrative\",\r\n        \"elementType\": \"labels.text\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"on\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"landscape\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"on\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"poi\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"on\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"road\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"on\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"transit\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"on\"\r\n            }\r\n        ]\r\n    },\r\n    {\r\n        \"featureType\": \"water\",\r\n        \"elementType\": \"all\",\r\n        \"stylers\": [\r\n            {\r\n                \"visibility\": \"on\"\r\n            }\r\n        ]\r\n    }\r\n]","listing":{"listing_header":"Locations Listing","display_search_form":true,"search_field_autosuggest":false,"display_category_filter":false,"display_sorting_filter":true,"display_radius_filter":false,"radius_dimension":"miles","radius_options":"100,200,300,400,500","apply_default_radius":false,"default_radius_dimension":"miles","display_location_per_page_filter":false,"display_print_option":true,"display_grid_option":false,"filters":["place_category"],"sorting_options":{"category__asc":"A-Z Category","category__desc":"Z-A Category","title__asc":"A-Z Title","title__desc":"Z-A Title","address__asc":"A-Z Address","address__desc":"Z-A Address"},"default_sorting":{"orderby":"category","inorder":"desc"},"listing_container":".location_listing5","tabs_container":".location_listing5","hide_locations":false,"filters_position":"top_map","hide_map":false,"pagination":{"listing_per_page":"100"},"list_grid":"wpgmp_listing_grid","listing_placeholder":"<div class=\"fc-item-box fc-component-2 wpgmp_locations \">\r\n    <div class=\"fc-component-block\">\r\n        <div class=\"fc-component-content\">\r\n            <ul>\r\n                <li class=\"fc-item-featured fc-component-thumb fc-item-top_space\">\r\n                    <div class=\"fc-featured-hoverdiv\">\r\n                        <div class=\"fc-featured-hoverinner \"><a {onclick_action}=\"\" class=\"map\"></a></div>\r\n                        {marker_image}\r\n                    </div>\r\n                </li>\r\n\r\n                <li class=\"fc-component-text\">\r\n                    <div class=\"fc-itemcontent-padding\">\r\n                        <div class=\"fc-item-title fc-item-primary-text-color \">{marker_title}</div>\r\n                        <div class=\"fc-location-marker fc-css\">{city_country}</div>\r\n                        <div class=\"fc-item-content fc-item-body-text-color\">\r\n                            {marker_message}\r\n                        </div>\r\n                        <a href=\"{post_link}\" class=\"read-more fc-item-primary-text-color fc-css\">Read More</a>\r\n                    </div>\r\n                </li>\r\n            </ul>\r\n        </div>\r\n    </div>\r\n</div>","list_item_skin":{"name":"aare","type":"item","sourcecode":"&lt;div class=&quot;fc-item-box fc-component-2 wpgmp_locations &quot;&gt;\r\n    &lt;div class=&quot;fc-component-block&quot;&gt;\r\n        &lt;div class=&quot;fc-component-content&quot;&gt;\r\n            &lt;ul&gt;\r\n                &lt;li class=&quot;fc-item-featured fc-component-thumb fc-item-top_space&quot;&gt;\r\n                    &lt;div class=&quot;fc-featured-hoverdiv&quot;&gt;\r\n                        &lt;div class=&quot;fc-featured-hoverinner &quot;&gt;&lt;a {onclick_action}=&quot;&quot; class=&quot;map&quot;&gt;&lt;/a&gt;&lt;/div&gt;\r\n                        {marker_image}\r\n                    &lt;/div&gt;\r\n                &lt;/li&gt;\r\n\r\n                &lt;li class=&quot;fc-component-text&quot;&gt;\r\n                    &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n                        &lt;div class=&quot;fc-item-title fc-item-primary-text-color &quot;&gt;{marker_title}&lt;/div&gt;\r\n                        &lt;div class=&quot;fc-location-marker fc-css&quot;&gt;{city_country}&lt;/div&gt;\r\n                        &lt;div class=&quot;fc-item-content fc-item-body-text-color&quot;&gt;\r\n                            {marker_message}\r\n                        &lt;/div&gt;\r\n                        &lt;a href=&quot;{post_link}&quot; class=&quot;read-more fc-item-primary-text-color fc-css&quot;&gt;Read More&lt;/a&gt;\r\n                    &lt;/div&gt;\r\n                &lt;/li&gt;\r\n            &lt;/ul&gt;\r\n        &lt;/div&gt;\r\n    &lt;/div&gt;\r\n&lt;/div&gt;"}},"map_property":{"map_id":"5","debug_mode":true},"map_marker_spiderfier_setting":{"minimum_markers":"0"},"shapes":{"drawing_editable":false},"filters":{"filters_container":"[data-container=\"wpgmp-filters-container\"]"},"marker_category_icons":{"1":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"layoutManager":true,"zoomLevel":"3"}